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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.Threading;
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
class SignalGate
{
[Fx.Tag.SynchronizationObject(Blocking = false, Kind = Fx.Tag.SynchronizationKind.InterlockedNoSpin)]
int state;
public SignalGate()
{
}
internal bool IsLocked
{
get
{
return this.state == GateState.Locked;
}
}
internal bool IsSignalled
{
get
{
return this.state == GateState.Signalled;
}
}
// Returns true if this brings the gate to the Signalled state.
// Transitions - Locked -> SignalPending | Completed before it was unlocked
// Unlocked -> Signaled
public bool Signal()
{
int lastState = this.state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref this.state, GateState.SignalPending, GateState.Locked);
}
if (lastState == GateState.Unlocked)
{
this.state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// Returns true if this brings the gate to the Signalled state.
// Transitions - SignalPending -> Signaled | return the AsyncResult since the callback already
// | completed and provided the result on its thread
// Locked -> Unlocked
public bool Unlock()
{
int lastState = this.state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref this.state, GateState.Unlocked, GateState.Locked);
}
if (lastState == GateState.SignalPending)
{
this.state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// This is factored out to allow Signal and Unlock to be inlined.
void ThrowInvalidSignalGateState()
{
throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.InvalidSemaphoreExit));
}
static class GateState
{
public const int Locked = 0;
public const int SignalPending = 1;
public const int Unlocked = 2;
public const int Signalled = 3;
}
}
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
class SignalGate<T> : SignalGate
{
T result;
public SignalGate()
: base()
{
}
public bool Signal(T result)
{
this.result = result;
return Signal();
}
public bool Unlock(out T result)
{
if (Unlock())
{
result = this.result;
return true;
}
result = default(T);
return false;
}
}
}
|
