private static PortableFileObject AddFileObject
(
string filePath,
PortableDirectorySource directorySource,
ReaderWriterLockSlim objectsLock,
Func <PortableDirectorySource, string, PortableFileObject> createObject
)
{
_objectLoadingTask.ThrowIfUnitialised(nameof(_fileObjectDescriber),
nameof(AddFileObject),
nameof(RegisterPlatformSpecific));
string fileName = Path.GetFileName(filePath);
DateTime fileTime = _fileObjectDescriber.GetFileCreationTime(filePath);
PortableFileObject fileObject = createObject(directorySource,
fileName);
directorySource.AddObject(fileObject);
objectsLock?.EnterWriteLock();
try
{
_cachedObjects.Add(fileObject);
}
finally
{
objectsLock?.ExitWriteLock();
}
return(fileObject);
}
/// <inheritdoc/>
public T this[int index]
{
get
{
CheckIndex(index);
try
{
ReaderWriterLock?.EnterReadLock();
return(MemUtil.GetRef <T>(GetPtr(index)));
}
finally
{
ReaderWriterLock?.ExitReadLock();
}
}
set
{
CheckIndex(index);
try
{
ReaderWriterLock?.EnterWriteLock();
MemUtil.GetRef <T>(GetPtr(index)) = value;
}
finally
{
ReaderWriterLock?.ExitWriteLock();
}
}
}
public static void EnterExit()
{
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim())
{
Assert.False(rwls.IsReadLockHeld);
rwls.EnterReadLock();
Assert.True(rwls.IsReadLockHeld);
rwls.ExitReadLock();
Assert.False(rwls.IsReadLockHeld);
Assert.False(rwls.IsUpgradeableReadLockHeld);
rwls.EnterUpgradeableReadLock();
Assert.True(rwls.IsUpgradeableReadLockHeld);
rwls.ExitUpgradeableReadLock();
Assert.False(rwls.IsUpgradeableReadLockHeld);
Assert.False(rwls.IsWriteLockHeld);
rwls.EnterWriteLock();
Assert.True(rwls.IsWriteLockHeld);
rwls.ExitWriteLock();
Assert.False(rwls.IsWriteLockHeld);
Assert.False(rwls.IsUpgradeableReadLockHeld);
rwls.EnterUpgradeableReadLock();
Assert.False(rwls.IsWriteLockHeld);
Assert.True(rwls.IsUpgradeableReadLockHeld);
rwls.EnterWriteLock();
Assert.True(rwls.IsWriteLockHeld);
rwls.ExitWriteLock();
Assert.False(rwls.IsWriteLockHeld);
Assert.True(rwls.IsUpgradeableReadLockHeld);
rwls.ExitUpgradeableReadLock();
Assert.False(rwls.IsUpgradeableReadLockHeld);
Assert.True(rwls.TryEnterReadLock(0));
rwls.ExitReadLock();
Assert.True(rwls.TryEnterReadLock(Timeout.InfiniteTimeSpan));
rwls.ExitReadLock();
Assert.True(rwls.TryEnterUpgradeableReadLock(0));
rwls.ExitUpgradeableReadLock();
Assert.True(rwls.TryEnterUpgradeableReadLock(Timeout.InfiniteTimeSpan));
rwls.ExitUpgradeableReadLock();
Assert.True(rwls.TryEnterWriteLock(0));
rwls.ExitWriteLock();
Assert.True(rwls.TryEnterWriteLock(Timeout.InfiniteTimeSpan));
rwls.ExitWriteLock();
}
}
private TRead BodyReadWriteNotify <TRead>(TRead readValue, Func <TRead, TInternalCollection> write, Func <TRead, NotifyCollectionChangedEventArgs> change)
{
_lock?.EnterWriteLock();
_internalCollection = write(readValue);
var changeValue = change(readValue);
if (changeValue != null)
{
OnCollectionChanged(changeValue);
}
_lock?.ExitWriteLock();
_lock?.ExitUpgradeableReadLock();
_viewChanged.InvokeAction();
return(readValue);
}
public static int WriteLines <T>([NotNull] this StreamWriter thisValue, [NotNull] ICollection <T> lines, ReaderWriterLockSlim writerLock = null)
{
if (lines == null)
{
throw new ArgumentNullException(nameof(lines));
}
if (lines.Count == 0)
{
return(0);
}
int result = 0;
writerLock?.EnterWriteLock();
try
{
if (lines.Count == 1)
{
thisValue.Write(lines.First());
result++;
}
else
{
foreach (T line in lines.Take(lines.Count - 1))
{
thisValue.WriteLine(line);
result++;
}
thisValue.Write(lines.Last());
result++;
}
}
catch
{
result = -1;
}
finally
{
writerLock?.ExitWriteLock();
}
return(result);
}
protected virtual void Dispose(bool isDisposing)
{
if (isDisposing)
{
_lock?.EnterWriteLock();
try
{
_db?.Entries?.Clear();
_db = null;
}
finally
{
_lock?.ExitWriteLock();
_lock?.Dispose();
_lock = null;
}
}
}
public static bool WriteLineWithLock <T>([NotNull] this StreamWriter thisValue, T value, ReaderWriterLockSlim writerLock = null)
{
if (value == null)
{
return(false);
}
writerLock?.EnterWriteLock();
try
{
thisValue.WriteLine(value);
return(true);
}
catch
{
return(false);
}
finally
{
writerLock?.ExitWriteLock();
}
}
public static void Dispose()
{
ReaderWriterLockSlim rwls;
rwls = new ReaderWriterLockSlim();
rwls.Dispose();
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterReadLock(0));
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterUpgradeableReadLock(0));
Assert.Throws<ObjectDisposedException>(() => rwls.TryEnterWriteLock(0));
rwls.Dispose();
for (int i = 0; i < 3; i++)
{
rwls = new ReaderWriterLockSlim();
switch (i)
{
case 0: rwls.EnterReadLock(); break;
case 1: rwls.EnterUpgradeableReadLock(); break;
case 2: rwls.EnterWriteLock(); break;
}
Assert.Throws<SynchronizationLockException>(() => rwls.Dispose());
}
}
public void Close()
{
if (_dbLock == null)
{
return;
}
_compactTask?.Wait();
_dbLock?.EnterWriteLock();
if (_dbLock == null)
{
return;
}
try
{
if (_compactTimer != null)
{
var timeFinishWaiter = new ManualResetEvent(false);
_compactTimer.Dispose(timeFinishWaiter);
timeFinishWaiter.WaitOne();
}
_memCache = null;
_log?.Close();
_log = null;
_manifest?.Close();
_manifest = null;
}
finally
{
var dbLock = _dbLock;
_dbLock = null;
dbLock.ExitWriteLock();
dbLock?.Dispose();
}
}
public IEnumerator <T> GetEnumerator()
{
if (cache is ImmutableArray <T> )
{
foreach (T item in cache)
{
yield return(item);
}
yield break;
}
lock (cache)
{
if (rwlock is null)
{
rwlock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
enumerator = enumerable.GetEnumerator();
enumerable = null;
}
}
int index = 0;
rwlock?.EnterUpgradeableReadLock();
while (index < cache.Count)
{
T item = cache[index++];
rwlock?.ExitUpgradeableReadLock();
yield return(item);
rwlock?.EnterUpgradeableReadLock();
}
rwlock.EnterWriteLock();
rwlock.ExitUpgradeableReadLock();
while (enumerator?.MoveNext() is true)
{
T item = enumerator.Current;
cache.Add(item);
rwlock.ExitWriteLock();
yield return(item);
++index;
rwlock?.EnterUpgradeableReadLock();
while (index < cache.Count)
{
item = cache[index++];
rwlock?.ExitUpgradeableReadLock();
yield return(item);
rwlock?.EnterUpgradeableReadLock();
}
rwlock?.EnterWriteLock();
rwlock?.ExitUpgradeableReadLock();
}
if (enumerator is null)
{
yield break;
}
cache = cache.ToImmutableArray();
ReaderWriterLockSlim templock = rwlock;
rwlock = null;
templock.ExitWriteLock();
while (templock.WaitingReadCount > 0)
{
// busy wait
}
templock.Dispose();
enumerator.Dispose();
enumerator = null;
}
public WriteLock(ReaderWriterLockSlim rwLock)
{
this.rwLock = rwLock;
rwLock.EnterWriteLock();
lockHeld = true;
}
/// <summary>
/// Gets the write lock, that is released when the object is disposed.
/// </summary>
/// <param name="slimLock">The slim lock.</param>
/// <returns></returns>
public static IDisposable GetWriteLock(this ReaderWriterLockSlim slimLock)
{
slimLock.EnterWriteLock();
return(new DisposableAction(slimLock.ExitWriteLock));
}
public void SaveUserStateValue(string state)
{
SessionLock.EnterWriteLock();
httpContext.Session[CacheId + "_state"] = state;
SessionLock.ExitWriteLock();
}
public static void WritersAreMutuallyExclusiveFromWriters()
{
using (Barrier barrier = new Barrier(2))
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim())
{
Task.WaitAll(
Task.Run(() =>
{
rwls.EnterWriteLock();
barrier.SignalAndWait();
Assert.True(rwls.IsWriteLockHeld);
barrier.SignalAndWait();
rwls.ExitWriteLock();
}),
Task.Run(() =>
{
barrier.SignalAndWait();
Assert.False(rwls.TryEnterWriteLock(0));
Assert.False(rwls.IsReadLockHeld);
barrier.SignalAndWait();
}));
}
}
public static void DeadlockAvoidance()
{
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim())
{
rwls.EnterReadLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock());
Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock());
Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock());
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
rwls.EnterReadLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock());
rwls.ExitReadLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock());
rwls.EnterWriteLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock());
rwls.ExitWriteLock();
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterReadLock());
Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock());
Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock());
rwls.ExitWriteLock();
}
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion))
{
rwls.EnterReadLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterWriteLock());
rwls.EnterReadLock();
Assert.Throws<LockRecursionException>(() => rwls.EnterUpgradeableReadLock());
rwls.ExitReadLock();
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
rwls.EnterReadLock();
rwls.EnterUpgradeableReadLock();
rwls.ExitUpgradeableReadLock();
rwls.EnterReadLock();
rwls.ExitReadLock();
rwls.ExitReadLock();
rwls.EnterWriteLock();
rwls.EnterWriteLock();
rwls.ExitWriteLock();
rwls.ExitWriteLock();
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
rwls.EnterReadLock();
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
rwls.ExitWriteLock();
rwls.ExitWriteLock();
}
}
public WriteLockToken(ReaderWriterLockSlim sync)
{
_sync = sync;
sync.EnterWriteLock();
}
internal WriteLockExiter(ReaderWriterLockSlim @lock)
{
_lock = @lock;
@lock.EnterWriteLock();
}
public void EnterWrite()
{
_lock.EnterWriteLock();
}
public void ExecuteBatchIfNotAlreadyStarted()
{
/*
* - check that we only execute once since there's multiple paths to do so (timer, waiting thread or max batch size hit)
* - close the gate so 'offer' can no longer be invoked and we turn those threads away so they create a new batch
*/
if (_batchStarted.CompareAndSet(false, true))
{
/* wait for 'offer'/'remove' threads to finish before executing the batch so 'requests' is complete */
_batchLock.EnterWriteLock();
var args = new List <CollapsedRequest <RequestResponseType, RequestArgumentType> >();
try
{
// Check for cancel
foreach (var entry in _argumentMap)
{
if (!entry.Value.IsRequestCanceled())
{
args.Add(entry.Value);
}
}
// Handle case of null arg submit
if (_nullArg.Value != null)
{
var req = _nullArg.Value;
if (!req.IsRequestCanceled())
{
args.Add(req);
}
}
if (args.Count > 0)
{
// shard batches
var shards = _commandCollapser.DoShardRequests(args);
// for each shard execute its requests
foreach (var shardRequests in shards)
{
try
{
// create a new command to handle this batch of requests
var command = _commandCollapser.DoCreateObservableCommand(shardRequests);
var result = command.Execute();
try
{
_commandCollapser.DoMapResponseToRequests(result, shardRequests);
}
catch (Exception mapException)
{
// logger.debug("Exception mapping responses to requests.", e);
foreach (var request in args)
{
try
{
request.SetExceptionIfResponseNotReceived(mapException);
}
catch (InvalidOperationException)
{
// if we have partial responses set in mapResponseToRequests
// then we may get InvalidOperationException as we loop over them
// so we'll log but continue to the rest
// logger.error("Partial success of 'mapResponseToRequests' resulted in InvalidOperationException while setting Exception. Continuing ... ", e2);
}
}
}
// check that all requests had setResponse or setException invoked in case 'mapResponseToRequests' was implemented poorly
Exception e = null;
foreach (var request in shardRequests.OfType <CollapsedRequest <RequestResponseType, RequestArgumentType> >())
{
try
{
e = request.SetExceptionIfResponseNotReceived(e, "No response set by " + _commandCollapser.CollapserKey.Name + " 'mapResponseToRequests' implementation.");
}
catch (InvalidOperationException)
{
// logger.debug("Partial success of 'mapResponseToRequests' resulted in InvalidOperationException while setting 'No response set' Exception. Continuing ... ", e2);
}
}
}
catch (Exception e)
{
// logger.error("Exception while creating and queueing command with batch.", e);
// if a failure occurs we want to pass that exception to all of the Futures that we've returned
foreach (var request in shardRequests.OfType <CollapsedRequest <RequestResponseType, RequestArgumentType> >())
{
try
{
request.Exception = e;
}
catch (InvalidOperationException)
{
// logger.debug("Failed trying to setException on CollapsedRequest", e2);
}
}
}
}
}
}
catch (Exception e)
{
// logger.error("Exception while sharding requests.", e);
// same error handling as we do around the shards, but this is a wider net in case the shardRequest method fails
foreach (ICollapsedRequest <RequestResponseType, RequestArgumentType> request in args)
{
try
{
request.Exception = e;
}
catch (InvalidOperationException)
{
// logger.debug("Failed trying to setException on CollapsedRequest", e2);
}
}
}
finally
{
_batchLock.ExitWriteLock();
}
}
}
// test
// private readonly static Cache<int, int> cache = new Cache<int, int>();
//private static List<int> Build(int count)
//{
// List<int> list = new List<int>();
// for (int i = 0; i < 100; i++)
// {
// for (int j = 0; j < count; j++)
// {
// list.Add(i);
// }
// }
// return list;
//}
// main test method :
//var list=Build(8);
//var stopwatch = Stopwatch.StartNew();
//Parallel.ForEach(list, new ParallelOptions() { MaxDegreeOfParallelism = 8 }, (j) => {
// cache.Get(j, () => {
// Thread.Sleep(1);
// return j;
// });
//});
//stopwatch.Stop();
//Console.Write(" " + stopwatch.ElapsedMilliseconds.ToString().PadRight(4));
public TValue Get(TKey key, Func <TValue> factory)
{
if (object.Equals(key, null))
{
return(factory());
}
TValue val;
_lock.EnterReadLock();
try
{
if (_map.TryGetValue(key, out val))
{
return(val);
}
}
finally { _lock.ExitReadLock(); }
AntiDupLockSlim slim;
_slimLock.EnterUpgradeableReadLock();
try
{
_lock.EnterReadLock();
try
{
if (_map.TryGetValue(key, out val))
{
return(val);
}
}
finally { _lock.ExitReadLock(); }
_slimLock.EnterWriteLock();
try
{
if (_lockDict.TryGetValue(key, out slim) == false)
{
slim = new AntiDupLockSlim();
_lockDict[key] = slim;
}
slim.UseCount++;
}
finally { _slimLock.ExitWriteLock(); }
}
finally { _slimLock.ExitUpgradeableReadLock(); }
slim.EnterWriteLock();
try
{
_lock.EnterReadLock();
try
{
if (_map.TryGetValue(key, out val))
{
return(val);
}
}
finally { _lock.ExitReadLock(); }
val = factory();
_lock.EnterWriteLock();
try
{
_map[key] = val;
}
finally { _lock.ExitWriteLock(); }
return(val);
}
finally
{
slim.ExitWriteLock();
_slimLock.EnterWriteLock();
try
{
slim.UseCount--;
if (slim.UseCount == 0)
{
_lockDict.Remove(key);
slim.Dispose();
}
}
finally { _slimLock.ExitWriteLock(); }
}
}
public override int GetOrdinal(FacetLabel cp)
{
EnsureOpen();
if (cp.Length == 0)
{
return(ROOT_ORDINAL);
}
// First try to find the answer in the LRU cache:
// LUCENENET: Despite LRUHashMap being thread-safe, we get much better performance
// if reads are separated from writes.
ordinalCacheLock.EnterReadLock();
try
{
if (ordinalCache.TryGetValue(cp, out Int32Class res))
{
if (res < indexReader.MaxDoc)
{
// Since the cache is shared with DTR instances allocated from
// doOpenIfChanged, we need to ensure that the ordinal is one that
// this DTR instance recognizes.
return(res);
}
else
{
// if we get here, it means that the category was found in the cache,
// but is not recognized by this TR instance. Therefore there's no
// need to continue search for the path on disk, because we won't find
// it there too.
return(TaxonomyReader.INVALID_ORDINAL);
}
}
}
finally
{
ordinalCacheLock.ExitReadLock();
}
// If we're still here, we have a cache miss. We need to fetch the
// value from disk, and then also put it in the cache:
int ret = TaxonomyReader.INVALID_ORDINAL;
DocsEnum docs = MultiFields.GetTermDocsEnum(indexReader, null, Consts.FULL, new BytesRef(FacetsConfig.PathToString(cp.Components, cp.Length)), 0);
if (docs != null && docs.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
{
ret = docs.DocID;
// we only store the fact that a category exists, not its inexistence.
// This is required because the caches are shared with new DTR instances
// that are allocated from doOpenIfChanged. Therefore, if we only store
// information about found categories, we cannot accidently tell a new
// generation of DTR that a category does not exist.
ordinalCacheLock.EnterWriteLock();
try
{
ordinalCache[cp] = ret;
}
finally
{
ordinalCacheLock.ExitWriteLock();
}
}
return(ret);
}
public void EnterWriteLock()
{
rwls.EnterWriteLock();
}
public object this[object key]
{
get
{
if (key == null)
{
return(null);
}
_itemsLock.EnterUpgradeableReadLock();
try
{
WCFCacheItem res = (WCFCacheItem)_items[key];
if (res != null)
{
if (res.SlidingExpirationTime.TotalMilliseconds > 0)
{
_itemsLock.EnterWriteLock();
try
{
res.LastAccessTime = DateTime.Now;
}
finally
{
_itemsLock.ExitWriteLock();
}
}
return(res.ItemValue);
}
else
{
return(null);
}
}
finally
{
_itemsLock.ExitUpgradeableReadLock();
}
}
set
{
_itemsLock.EnterWriteLock();
try
{
_items[key] = new WCFCacheItem(value);
}
finally
{
_itemsLock.ExitWriteLock();
}
}
}
public static IDisposable UseWriteLock(this ReaderWriterLockSlim locker)
{
locker?.EnterWriteLock();
return(new DisposeActionWrapper(() => locker?.ExitWriteLock()));
}
public static void InvalidExits(LockRecursionPolicy policy)
{
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim(policy))
{
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.EnterReadLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitReadLock();
rwls.EnterUpgradeableReadLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
rwls.ExitUpgradeableReadLock();
rwls.EnterWriteLock();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitReadLock());
Assert.Throws<SynchronizationLockException>(() => rwls.ExitUpgradeableReadLock());
rwls.ExitWriteLock();
using (Barrier barrier = new Barrier(2))
{
Task t = Task.Factory.StartNew(() =>
{
rwls.EnterWriteLock();
barrier.SignalAndWait();
barrier.SignalAndWait();
rwls.ExitWriteLock();
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
barrier.SignalAndWait();
Assert.Throws<SynchronizationLockException>(() => rwls.ExitWriteLock());
barrier.SignalAndWait();
t.GetAwaiter().GetResult();
}
}
}
public IDisposable LockWrite()
{
return(new ActionDisposable(() => @lock.EnterWriteLock(), () => @lock.ExitWriteLock()));
}
public static void WriterToUpgradeableReaderChain()
{
using (AutoResetEvent are = new AutoResetEvent(false))
using (ReaderWriterLockSlim rwls = new ReaderWriterLockSlim())
{
rwls.EnterWriteLock();
Task t = Task.Factory.StartNew(() =>
{
Assert.False(rwls.TryEnterUpgradeableReadLock(TimeSpan.FromMilliseconds(10)));
Task.Run(() => are.Set()); // ideally this won't fire until we've called EnterReadLock, but it's a benign race in that the test will succeed either way
rwls.EnterUpgradeableReadLock();
rwls.ExitUpgradeableReadLock();
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
are.WaitOne();
rwls.ExitWriteLock();
t.GetAwaiter().GetResult();
}
}
private async Task WebSocketRequest(AspNetWebSocketContext context)
{
// Получаем сокет клиента из контекста запроса
var socket = context.WebSocket;
// Добавляем его в список клиентов
Locker.EnterWriteLock();
try
{
Clients.Add(socket);
}
finally
{
Locker.ExitWriteLock();
}
// Слушаем его
while (true)
{
var buffer = new ArraySegment <byte>(new byte[1024]);
var testBuffer = new ArraySegment <byte>(new byte[1024]);
// Ожидаем данные от него
var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
var message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
if (socket == Clients[0])
{
string[] separators = { ":", " " };
string[] words = message.Split(separators, StringSplitOptions.RemoveEmptyEntries);
if (words.Length == 2)
{
todos.Enqueue(new Todo(words[0], words[1]));
}
if (socket.State == WebSocketState.Open)
{
var msgBytes = Encoding.UTF8.GetBytes("status");
await Clients[1].SendAsync(new ArraySegment <byte>(msgBytes, 0, msgBytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
await Clients[2].SendAsync(new ArraySegment <byte>(msgBytes, 0, msgBytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
//await Clients[1].SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
if (socket == Clients[1])
{
if (socket.State == WebSocketState.Open)
{
if ((message == "w1 able") && (todos.Count != 0))
{
Todo todo = todos.Dequeue();
var msgBytes = Encoding.UTF8.GetBytes(todo.Param1 + " " + todo.Param2);
await Clients[1].SendAsync(new ArraySegment <byte>(msgBytes, 0, msgBytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
await Clients[0].SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
if (socket == Clients[2])
{
if (socket.State == WebSocketState.Open)
{
if ((message == "w2 able") && (todos.Count != 0))
{
Todo todo = todos.Dequeue();
var msgBytes = Encoding.UTF8.GetBytes(todo.Param1 + " " + todo.Param2);
await Clients[2].SendAsync(new ArraySegment <byte>(msgBytes, 0, msgBytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
await Clients[0].SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
////Передаём сообщение всем клиентам
//for (int i = 0; i < Clients.Count; i++)
//{
// WebSocket client = Clients[i];
// try
// {
// if (client.State == WebSocketState.Open)
// {
// await client.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
// }
// }
// catch (ObjectDisposedException)
// {
// Locker.EnterWriteLock();
// try
// {
// Clients.Remove(client);
// i--;
// }
// finally
// {
// Locker.ExitWriteLock();
// }
// }
//}
}
}
/// <summary>
/// Acquires a new write lock.
/// </summary>
/// <param name="readWriteLock">The wrapped lock</param>
public WriteLock(ReaderWriterLockSlim readWriteLock)
{
_readWriteLock = readWriteLock;
_readWriteLock.EnterWriteLock();
}
/// <summary>
/// Initializes a new instance of the <see cref="WriteLockDisposable"/> class.
/// </summary>
/// <param name="rwLock">The rw lock.</param>
public WriteLockDisposable(ReaderWriterLockSlim rwLock)
{
_rwLock = rwLock;
_rwLock.EnterWriteLock();
}
/// <summary>
/// 创建报盘通道，每一个服务地址维护一个实例
/// 即一个撮合中心一个下单连接
/// </summary>
/// <param name="strIp">服务器</param>
/// <param name="strPort">服务器端口</param>
/// <param name="strDoOrderServiceName">下单服务名</param>
/// <param name="strDealRptServiceName">成交回送服务名</param>
/// <param name="state">成交回送通道状态</param>
/// <param name="strMessage"></param>
/// <returns>报盘通道实例</returns>
public DoOrderClient GetDoOrderChannel(string strIp, string strPort,
string strDoOrderServiceName, string strDealRptServiceName,
ref ChannelState state, ref string strMessage)
{
LogHelper.WriteDebug("ServiceChannelManger.GetDoOrderChannel");
DoOrderClient resultObj = null;
if (_wcfDoOrderChannelList != null)
{
var strDoOrderAddress = string.Format("net.tcp://{0}:{1}/{2}", strIp, strPort, strDoOrderServiceName);
string strPort2 = "";
try
{
int dealPort = int.Parse(strPort);
dealPort++;
strPort2 = dealPort.ToString();
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
strPort2 = strPort;
}
var strDealRptAddress = string.Format("net.tcp://{0}:{1}/{2}", strIp, strPort2,
strDealRptServiceName);
_wcfDealRptChannelListLock.EnterUpgradeableReadLock();
try
{
//如果缓存中没有，那么新建
if (!_wcfDoOrderChannelList.TryGetValue(strDoOrderAddress, out resultObj))
{
_wcfDealRptChannelListLock.EnterWriteLock();
try
{
var doOrderChannel = CreateDoOrderChannel(strDoOrderAddress, ref strMessage);
if (doOrderChannel != null)
{
resultObj = doOrderChannel;
_wcfDoOrderChannelList[strDoOrderAddress] = doOrderChannel;
var dealBackChannel = this.CreateDealRptChannel(strDealRptAddress, ref strMessage);
if (dealBackChannel != null)
{
_wcfDealRptChannelList[strDealRptAddress] = new DealRptChannelState(dealBackChannel,
ChannelState.
CSNormal,
strDealRptAddress);
}
}
}
finally
{
_wcfDealRptChannelListLock.ExitWriteLock();
}
}
else
{
if (resultObj != null &&
((_wcfDealRptChannelList[strDealRptAddress].State == ChannelState.CSError) ||
(resultObj.State == CommunicationState.Faulted ||
resultObj.State == CommunicationState.Closed)))
{
_wcfDealRptChannelListLock.EnterWriteLock();
try
{
LogHelper.WriteInfo("ServiceChannelManager.GetDoOrderChannel下单通道出错，状态为" +
resultObj.State);
RemoveDoOrderAndRptChannel(strDoOrderAddress, strDealRptAddress);
resultObj = null;
}
finally
{
_wcfDealRptChannelListLock.ExitWriteLock();
}
}
}
}
finally
{
_wcfDealRptChannelListLock.ExitUpgradeableReadLock();
}
#region old code
//lock (((ICollection) _wcfDealRptChannelList).SyncRoot)
//{
// var strDoOrderAddress = string.Format("net.tcp://{0}:{1}/{2}", strIp, strPort, strDoOrderServiceName);
// string strPort2 = "";
// try
// {
// int dealPort = int.Parse(strPort);
// dealPort++;
// strPort2 = dealPort.ToString();
// }
// catch (Exception ex)
// {
// LogHelper.WriteError(ex.Message, ex);
// strPort2 = strPort;
// }
// var strDealRptAddress = string.Format("net.tcp://{0}:{1}/{2}", strIp, strPort2,
// strDealRptServiceName);
// //如果缓存中没有，那么新建
// if (!_wcfDoOrderChannelList.ContainsKey(strDoOrderAddress))
// {
// var doOrderChannel = CreateDoOrderChannel(strDoOrderAddress, ref strMessage);
// if (doOrderChannel != null)
// {
// resultObj = doOrderChannel;
// _wcfDoOrderChannelList[strDoOrderAddress] = doOrderChannel;
// var dealBackChannel = this.CreateDealRptChannel(strDealRptAddress, ref strMessage);
// if (dealBackChannel != null)
// {
// _wcfDealRptChannelList[strDealRptAddress] = new DealRptChannelState(dealBackChannel,
// ChannelState.
// CSNormal,
// strDealRptAddress);
// }
// }
// }
// //if (_wcfDoOrderChannelList.ContainsKey(strDoOrderAddress))
// else
// {
// resultObj = _wcfDoOrderChannelList[strDoOrderAddress];
// if (resultObj != null &&
// ((_wcfDealRptChannelList[strDealRptAddress].State == ChannelState.CSError) ||
// (resultObj.State == CommunicationState.Faulted ||
// resultObj.State == CommunicationState.Closed)))
// {
// //_wcfDoOrderChannelList.Remove(strDoOrderAddress);
// //_wcfDealRptChannelList.Remove(strDealRptAddress);
// LogHelper.WriteDebug("ServiceChannelManager.GetDoOrderChannel下单通道出错，状态为" + resultObj.State);
// RemoveDoOrderAndRptChannel(strDoOrderAddress, strDealRptAddress);
// resultObj = null;
// }
// }
//}
#endregion
}
return(resultObj);
}
public void Add(EventHandler <T> action)
{
_Locker.EnterWriteLock();
_Actions.Add(action);
_Locker.ExitWriteLock();
}
protected void EnterWriteLock() => _lock?.EnterWriteLock();
public IDisposable AcquireWriterLock()
{
Locker?.EnterWriteLock();
return(new SlimLockHolder(this, LockHolderType.Write));
}
/// <inheritdoc />
public IDisposable AcquireWriterLock()
{
_locker?.EnterWriteLock();
return(new SyncLockReleaser(this, LockHolderType.Write));
}
/// <summary>
/// 更新积分统计
/// </summary>
/// <param name="userId">用户Id</param>
/// <param name="pointCategory2PointsDictionary"><remarks>key=PointCategory,value=Points</remarks>积分分类-积分字典</param>
/// <returns>修订后应获取到的积分值</returns>
public Dictionary <string, int> UpdateStatistic(long userId, Dictionary <PointCategory, int> pointCategory2PointsDictionary)
{
Dictionary <string, int> dictionary = new Dictionary <string, int>();
RWLock.EnterWriteLock();
Database dao = CreateDAO();
try
{
dao.OpenSharedConnection();
//1、检查当日积分统计是否存在，不存在创建
//2、检查是否超过当日限额，如果未超过更新当日积分累计
var sql = Sql.Builder;
sql.Select("*")
.From("tn_PointStatistics")
.Where("UserId = @0", userId)
.Where("StatisticalYear = @0", DateTime.UtcNow.Year)
.Where("StatisticalMonth = @0", DateTime.UtcNow.Month)
.Where("StatisticalDay = @0", DateTime.UtcNow.Day);
IEnumerable <PointStatistic> pointStatistices = dao.Fetch <PointStatistic>(sql);
//初始化
foreach (var pair in pointCategory2PointsDictionary)
{
dictionary[pair.Key.CategoryKey] = pair.Value;
}
//当日积分统计不存在
if (pointStatistices == null || pointStatistices.Count() == 0)
{
//创建当日积分统计
foreach (var pair in pointCategory2PointsDictionary)
{
if (pair.Key.QuotaPerDay <= 0)
{
continue;
}
var pointStatistic = PointStatistic.New();
pointStatistic.UserId = userId;
pointStatistic.PointCategoryKey = pair.Key.CategoryKey;
pointStatistic.Points = pair.Value;
dao.Insert(pointStatistic);
}
}
else
{
//检查是积分限额，调整用户最终获取到的积分
foreach (var pair in pointCategory2PointsDictionary)
{
if (pair.Key.QuotaPerDay <= 0)
{
continue;
}
var category = pair.Key;
var pointStatistic = pointStatistices.FirstOrDefault(n => n.PointCategoryKey == category.CategoryKey);
if (pointStatistic == null)
{
continue;
}
if (pair.Value > 0 && pointStatistic.Points + pair.Value > category.QuotaPerDay)//超过限额
{
dictionary[pair.Key.CategoryKey] = 0;
}
else
{
pointStatistic.Points += pair.Value;
dao.Update(pointStatistic);
}
}
}
}
finally
{
dao.CloseSharedConnection();
RWLock.ExitWriteLock();
}
//更新用户分区缓存
RealTimeCacheHelper.IncreaseAreaVersion("UserId", userId);
return(dictionary);
}
