atomicity.h
|
C-/C++-Quelltext
|
1
2
|
__atomic_add
__exchange_and_add
|
Ich hab übrigens meine Quellcodes mal durchforstet und ein paar Codesnippets gefunden die zum Thema passen. Zum Beispiel ein abgespeckter Auszug meiner Threadsynchro Klassen:
|
C-/C++-Quelltext
|
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
struct ScopedLock;
struct Lockable
{
friend struct ScopedLock;
virtual ~Lockable() {}
private:
virtual void Lock() = 0;
virtual void Unlock() = 0;
};
struct ScopedLock : private Uncopyable
{
ScopedLock( Lockable& obj ) : locked( obj )
{
locked.Lock();
}
~ScopedLock()
{
locked.Unlock();
}
private:
Lockable& locked;
};
class LockPolicyMutex : Uncopyable
{
public:
LockPolicyMutex()
{
hMutex = CreateMutex( 0, false, 0 );
}
~LockPolicyMutex()
{
CloseHandle( hMutex );
}
void Lock()
{
WaitForSingleObject( hMutex, INFINITE );
}
void Unlock()
{
ReleaseMutex( hMutex );
}
private:
HANDLE hMutex;
};
class LockPolicyCriticalSection : Uncopyable
{
public:
LockPolicyCriticalSection()
{
InitializeCriticalSection( &cs );
}
~LockPolicyCriticalSection()
{
DeleteCriticalSection( &cs );
}
void DoLock()
{
EnterCriticalSection( &cs );
}
void DoUnlock()
{
LeaveCriticalSection( &cs );
}
private:
CRITICAL_SECTION cs;
};
template< class LockPolicy = LockPolicyCriticalSection >
class Mutex
: Uncopyable, public Lockable
{
public:
Mutex()
{}
private:
void Lock()
{
locker.DoLock();
}
void Unlock()
{
locker.DoUnlock();
}
LockPolicy locker;
};
|
Das Ganze ist Policybasiert, d.h. das Verhalten des Mutex lässt sich ggf recht einfach ändern. Ich hab mal zwei Möglichkeiten mitgesendet (Mutex und Critical Section). Die Klasse "ScopedLock" wird verwendet um einen bestimmten "Scope" zu sichern. Das ganze sollte auch Ausnahmesicher sein, dank des Destruktors.
Die ominöse Klasse Uncopyable gibts hier:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
|
/*
utility
*/
struct Uncopyable
{
protected:
Uncopyable() {}
private:
Uncopyable( const Uncopyable& );
Uncopyable& operator=( const Uncopyable& );
};
|
Das ganze verwendet sich dann so:
|
C-/C++-Quelltext
|
1
2
3
|
Mutex<> x;
ScopedLock lock( x );
|
Edit: Achja, atomic_inc und atomic_dec für den x86 mit M$ Syntax:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
|
inline void atomic_add( int* p )
{
_asm mov esi, [p]
_asm lock inc dword ptr[esi]
}
inline void atomic_dec( int* p )
{
_asm mov esi, [p]
_asm lock dec dword ptr[esi]
}
|