FilesExpand file tree

 master

/

MutexClass.cpp

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

84 lines (75 loc) · 1.7 KB

 master

/

MutexClass.cpp

Copy path

Top

File metadata and controls

• Code
• Blame

84 lines (75 loc) · 1.7 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

//

// MutexClass.cpp: implementation file

//

// Copyright (C) Walter E. Capers. All rights reserved

//

// This source is free to use as you like. If you make

// any changes please keep me in the loop. Email them to

// walt.capers@comcast.net.

//

// PURPOSE:

//

// To implement mutexes as a C++ object

//

// REVISIONS

// =======================================================

// Date: 10.25.07

// Name: Walter E. Capers

// Description: File creation

//

// Date:

// Name:

// Description:

//

//

#include "Thread.h"

CMutexClass::CMutexClass(void)

:m_bCreated(TRUE)

{

#ifdef WINDOWS

m_mutex = CreateMutex(NULL,FALSE,NULL);

if( !m_mutex ) m_bCreated = FALSE;

#else

pthread_mutexattr_t mattr;

pthread_mutexattr_init( &mattr );

pthread_mutex_init(&m_mutex,&mattr);

#endif

}

CMutexClass::~CMutexClass(void)

{

#ifdef WINDOWS

WaitForSingleObject(m_mutex,INFINITE);

CloseHandle(m_mutex);

#else

pthread_mutex_lock(&m_mutex);

pthread_mutex_unlock(&m_mutex);

pthread_mutex_destroy(&m_mutex);

#endif

}

void

CMutexClass::Lock()

{

ThreadId_t id = CThread::ThreadId();

if(CThread::ThreadIdsEqual(&m_owner,&id) )

return; // the mutex is already locked by this thread

#ifdef WINDOWS

WaitForSingleObject(m_mutex,INFINITE);

#else

pthread_mutex_lock(&m_mutex);

#endif

m_owner = CThread::ThreadId();

}

void

CMutexClass::Unlock()

{

ThreadId_t id = CThread::ThreadId();

if( ! CThread::ThreadIdsEqual(&id,&m_owner) )

return; // on the thread that has locked the mutex can release

// the mutex

memset(&m_owner,0,sizeof(ThreadId_t));

#ifdef WINDOWS

ReleaseMutex(m_mutex);

#else

pthread_mutex_unlock(&m_mutex);

#endif

}