/// <summary>
/// 添加寄存器
/// </summary>
/// <param name="reg"></param>
public void AddReg(CPLCAlarmReg reg)
{
try
{
objlock.AcquireWriterLock(-1);
regList.Add(reg);
if (!regMapp.ContainsKey(reg.idNo))
{
regMapp.Add(reg.idNo, regList.Count);
}
}
catch (Exception)
{
throw;
}
finally
{
objlock.ReleaseWriterLock();
}
}
internal /*public*/ ReaderWriterLockResource(ReaderWriterLock theLock, bool writerLock)
{
_lock = theLock;
_writerLock = writerLock;
if (_writerLock)
{
_lock.AcquireWriterLock(Timeout.Infinite);
}
else
{
_lock.AcquireReaderLock(Timeout.Infinite);
}
}
/// <summary>Disposes DHCP server</summary>
public void Dispose()
{
_abortLock.AcquireWriterLock(-1);
try
{
_abort = true;
_socket = null;
}
finally
{
_abortLock.ReleaseLock();
}
}
public static InProcListener AddListener(string aPath, Action <object> aListener)
{
InProcListener Result;
fLock.AcquireWriterLock(0x7fffffff);
try
{
if (!fQueue.TryGetValue(aPath, out Result))
{
Result = new InProcListener(aPath);
fQueue.Add(aPath, Result);
}
}
finally
{
fLock.ReleaseWriterLock();
}
lock (Result)
Result.AddLast(aListener);
return(Result);
}
public override void Close()
{
ReaderWriterLock.AcquireWriterLock();
try {
if (!IsClosing && !IsClosed) {
base.Close();
_handler.ConnectionClosed(this);
_rtmpNetworkStream.Close();
}
} finally {
ReaderWriterLock.ReleaseWriterLock();
}
}
public static void Write(object obj)
{
var num = new Random().Next(0, 1000);
//获取写锁
rw.AcquireWriterLock(TimeSpan.FromSeconds(30));
list.Add(num);
Console.WriteLine("我是线程{0}，我插入的数据是{1}。", Thread.CurrentThread.ManagedThreadId, num);
//释放写锁
rw.ReleaseWriterLock();
}
private IDisposable Lock(bool write)
{
if (write)
{
_rwLock.AcquireWriterLock(Timeout.Infinite);
}
else
{
_rwLock.AcquireReaderLock(Timeout.Infinite);
}
return(new LockReleaser(this, write));
}
/**
* <summary>
* Closes this client. No methods of this class can be used after this method was called.
* Any attempt to perform request on closed client will case <see cref="GridClientConnectionResetException"/>.
* All pending requests are failed without waiting for response.</summary>
*
* <param name="waitCompletion">If <c>true</c> this method will wait for all pending requests to be completed.</param>
*/
override sealed public void Close(bool waitCompletion)
{
closeLock.AcquireWriterLock(Timeout.Infinite);
try {
// Skip, if already closed.
if (closed)
{
return;
}
// Mark connection as closed.
this.closed = true;
this.closedIdle = false;
this.waitCompletion = waitCompletion;
}
finally {
closeLock.ReleaseWriterLock();
}
shutdown();
}
/// <summary>
/// Adds a player into the scene.
/// </summary>
/// <param name="player"></param>
public bool AddPlayer(GamePlayer player)
{
_locker.AcquireWriterLock(Timeout.Infinite);
try
{
//player.CurrentScene = this;
if (_players.ContainsKey(player.PlayerCharacter.ID))
{
_players[player.PlayerCharacter.ID] = player;
return(true);
}
else
{
_players.Add(player.PlayerCharacter.ID, player);
return(true);
}
}
finally
{
_locker.ReleaseWriterLock();
}
}
public void AddOrUpdateBlock(IBlock block)
{
var hash = block.BlockHashToHex;
_logger?.Trace($"Add or update block {hash} to block cache.");
_rwLock.AcquireWriterLock(Timeout);
try
{
var toRemove = _blockCache.FirstOrDefault(b => b.BlockHashToHex == hash);
if (toRemove?.Header != null)
{
_blockCache.Remove(toRemove);
}
_blockCache.Add(block.Clone());
_blockCache = _blockCache.OrderBy(b => b.Index).ToList();
}
finally
{
_rwLock.ReleaseWriterLock();
}
}
///<summary>
/// This method allows direct registration
/// of a session factory to a type, bypassing the normal preperation that AR
/// usually does.
/// The main usage is in testing, so you would be able to switch the session factory
/// for each test.
/// Note that this will override the current session factory for the baseType.
///</summary>
public void RegisterSessionFactory(ISessionFactory sessionFactory, Type baseType)
{
readerWriterLock.AcquireWriterLock(-1);
try
{
type2SessFactory[baseType] = sessionFactory;
}
finally
{
readerWriterLock.ReleaseWriterLock();
}
}
private void Log(string[] lines)
{
try
{
_locker.AcquireWriterLock(TimeSpan.FromSeconds(10));
lines.ToList().ForEach(Console.WriteLine);
File.AppendAllLines("log.txt", lines);
}
finally
{
_locker.ReleaseWriterLock();
}
}
private void TakeScreenshot(bool captureMouse)
{
if (captureMouse)
{
var bmp = ScreenCapturePInvoke.CaptureFullScreen(true);
rwl.AcquireWriterLock(Timeout.Infinite);
bmp.Save(AppDomain.CurrentDomain.BaseDirectory + "WebServer" + "/ScreenTask.jpg", ImageFormat.Jpeg);
rwl.ReleaseWriterLock();
//预览截屏
//if (isPreview)
//{
// img = new MemoryStream();
// bmp.Save(img, ImageFormat.Jpeg);
// imgPreview.Image = new Bitmap(img);
//}
return;
}
//Rectangle bounds = Screen.GetBounds(System.Drawing.Point.Empty);
Rectangle bounds = Bounds; //只截取指定范围
using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
{
using (Graphics g = Graphics.FromImage(bitmap))
{
g.CopyFromScreen(bounds.X, bounds.Y, 0, 0, bounds.Size);
}
rwl.AcquireWriterLock(Timeout.Infinite);
bitmap.Save(AppDomain.CurrentDomain.BaseDirectory + "WebServer" + "/ScreenTask.jpg", ImageFormat.Jpeg);
rwl.ReleaseWriterLock();
//预览截屏
//if (isPreview)
//{
// img = new MemoryStream();
// bitmap.Save(img, ImageFormat.Jpeg);
// imgPreview.Image = new Bitmap(img);
//}
}
}
private void DoAdd(T item)
{
sync.AcquireWriterLock(Timeout.Infinite);
collection.Add(item);
if (CollectionChanged != null)
{
CollectionChanged(this,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
sync.ReleaseWriterLock();
}
void RecycleCacheConnection(object sender, System.Timers.ElapsedEventArgs e)
{
_sync.AcquireWriterLock(Timeout.Infinite);
try
{
DisposeSecondaryCaches();
InitializeSecondaryCaches();
}
finally
{
_sync.ReleaseWriterLock();
}
}
/// <summary>
/// 写入数据的线程
/// </summary>
private static void ThreadWrite()
{
while (true)
{
myLock.AcquireWriterLock(int.MaxValue);//参数：表示最大的超时时间
Thread.Sleep(3000);
Console.WriteLine("---------------------------------------------当前写入的tid={0} {1}", Thread.CurrentThread.ManagedThreadId,
DateTime.Now.ToLongTimeString());
myLock.ReleaseWriterLock();
}
}
/// <summary>
/// Initializes the context for the current thread.
/// </summary>
/// <param name="contextId">The context Id string.</param>
/// <param name="contextListener">The <see cref="TraceListener"/> for the context.</param>
public void InitializeContext(string contextId, TraceListener contextListener)
{
listenerSyncLock.AcquireWriterLock(Timeout.Infinite);
try
{
listenerDictionary.Add(contextId, contextListener);
}
finally
{
listenerSyncLock.ReleaseWriterLock();
}
}
public void WriteToFile(LogModel logModel)
{
try
{
readerWriterLock.AcquireWriterLock(int.MaxValue);
string json = JsonConvert.SerializeObject(logModel);
File.AppendAllText("log.txt", json);
}
finally
{
readerWriterLock.ReleaseWriterLock();
}
}
public static void ClearCache()
{
// lock(LangTranslationCacheLock)
LangTranslationCacheLock.AcquireWriterLock(LockTimeout);
try
{
LangTranslationCaches.Clear();
}
finally
{
LangTranslationCacheLock.ReleaseWriterLock();
}
}
private void ResetOnTimer(object state)
{
//_timer.Change(Timeout.Infinite, Timeout.Infinite); //Останов таймера
_lock.AcquireWriterLock(_timeout);
try
{
_templates = null;
}
finally
{
_lock.ReleaseWriterLock();
}
}
public Keychain(ReaderWriterLock rwlock, bool write)
{
this.rwlock = rwlock;
this.write = write;
if (write)
{
rwlock.AcquireWriterLock(Timeout.Infinite);
}
else
{
rwlock.AcquireReaderLock(Timeout.Infinite);
}
}
/// <summary>
/// 将指定的键和值添加到字典中。
/// Exceptions：
/// ArgumentException - Dictionary 中已存在具有相同键的元素。
/// </summary>
/// <param name="key">要添加的元素的键。</param>
/// <param name="value">添加的元素的值。对于引用类型，该值可以为 空引用</param>
public static void Add(TKey key, TValue value)
{
bool isExisting = false;
rwLock.AcquireWriterLock(lockTimeOut);
try
{
if (!dictionary.ContainsKey(key))
{
dictionary.Add(key, value);
}
else
{
isExisting = true;
}
}
finally { rwLock.ReleaseWriterLock(); }
if (isExisting)
{
throw new IndexOutOfRangeException();
}
}
internal void SetLastWriteHeader(int channelId, RtmpHeader header)
{
try
{
ReaderWriterLock.AcquireWriterLock();
_lastWriteChannel = channelId;
_writeHeaders[channelId] = header;
}
finally
{
ReaderWriterLock.ReleaseWriterLock();
}
}
private void TakeScreenshot(bool captureMouse)
{
if (captureMouse)
{
var bmp = ScreenCapturePInvoke.CaptureSelectedScreen(true, comboScreens.SelectedIndex);
rwl.AcquireWriterLock(Timeout.Infinite);
bmp.Save(Application.StartupPath + "/WebServer" + "/ScreenTask.jpg", ImageFormat.Jpeg);
rwl.ReleaseWriterLock();
if (isPreview)
{
img = new MemoryStream();
bmp.Save(img, ImageFormat.Jpeg);
imgPreview.Image = new Bitmap(img);
}
bmp.Dispose();
bmp = null;
return;
}
Screen screen = Screen.AllScreens[comboScreens.SelectedIndex];
using (Bitmap bitmap = new Bitmap(screen.Bounds.Width, screen.Bounds.Height))
{
using (Graphics g = Graphics.FromImage(bitmap))
{
g.CopyFromScreen(screen.Bounds.X, screen.Bounds.Y, 0, 0, screen.Bounds.Size, CopyPixelOperation.SourceCopy);
}
rwl.AcquireWriterLock(Timeout.Infinite);
bitmap.Save(Application.StartupPath + "/WebServer" + "/ScreenTask.jpg", ImageFormat.Jpeg);
rwl.ReleaseWriterLock();
if (isPreview)
{
img = new MemoryStream();
bitmap.Save(img, ImageFormat.Jpeg);
imgPreview.Image = new Bitmap(img);
}
}
}
public static ECKeyPair FromPrivateKey(byte[] privateKey)
{
if (privateKey == null || privateKey.Length != 32)
{
throw new ArgumentException("Private key has to have length of 32.");
}
try
{
Lock.AcquireWriterLock(Timeout.Infinite);
var secp256K1PubKey = new byte[64];
Secp256K1.PublicKeyCreate(secp256K1PubKey, privateKey);
var pubKey = new byte[Secp256k1.SERIALIZED_UNCOMPRESSED_PUBKEY_LENGTH];
Secp256K1.PublicKeySerialize(pubKey, secp256K1PubKey);
return(new ECKeyPair(privateKey, pubKey));
}
finally
{
Lock.ReleaseWriterLock();
}
}
public async Task AddPlugin(Type lineResponderType)
{
_respondersLock.AcquireWriterLock(TimeSpan.FromSeconds(1));
if (!lineResponderType.GetInterfaces().Contains(typeof(ILineResponder)))
{
_respondersLock.ReleaseWriterLock();
throw new ArgumentException($"回應器類型必須實作{nameof(ILineResponder)}");
}
if (_respondersPipeline.Contains(lineResponderType))
{
_respondersLock.ReleaseWriterLock();
throw new ArgumentException($"回應器重複");
}
_respondersLock.ReleaseWriterLock();
_respondersLock.AcquireReaderLock(TimeSpan.FromSeconds(1));
_respondersPipeline.Add(lineResponderType);
_respondersLock.ReleaseReaderLock();
}
public MetaModel GetModel(Type dataContextType)
{
if (dataContextType == null)
{
throw Error.ArgumentNull("dataContextType");
}
MetaModel metaModel = null;
if (primaryModel == null)
{
metaModel = CreateModel(dataContextType);
Interlocked.CompareExchange(ref primaryModel, metaModel, null);
}
if (!(primaryModel.ContextType == dataContextType))
{
if (secondaryModels == null)
{
Interlocked.CompareExchange(ref secondaryModels, new Dictionary <Type, MetaModel>(), null);
}
if (rwlock == null)
{
Interlocked.CompareExchange(ref rwlock, new ReaderWriterLock(), null);
}
rwlock.AcquireReaderLock(-1);
MetaModel value;
try {
if (secondaryModels.TryGetValue(dataContextType, out value))
{
return(value);
}
} finally {
rwlock.ReleaseReaderLock();
}
rwlock.AcquireWriterLock(-1);
try {
if (!secondaryModels.TryGetValue(dataContextType, out value))
{
if (metaModel == null)
{
metaModel = CreateModel(dataContextType);
}
secondaryModels.Add(dataContextType, metaModel);
return(metaModel);
}
return(value);
} finally {
rwlock.ReleaseWriterLock();
}
}
return(primaryModel);
}
public static string Writeline(params object[] args)
{
if (args.Length == 0)
{
return(string.Empty);
}
String finalString = string.Empty;
finalString = String.Format("{0} - {1} ", DateTime.Now, Thread.CurrentThread.ManagedThreadId);
finalString += args[0];
for (int i = 1; i < args.Length; i++)
{
int j = i - 1;
string tempString = "{" + j.ToString() + "}";
string val = (args[i] != null) ? args[i].ToString() : string.Empty;
finalString = finalString.Replace(tempString, val);
}
try
{
Loggerlock.AcquireWriterLock(LOCK_TIMEOUT);
try
{
if ((Filestream == null) || (Streamwriter == null))
{
return(string.Empty);
}
Console.WriteLine(finalString);
Logger.CurrentFileLength = Logger.CurrentFileLength + finalString.Length;
if (Logger.CurrentFileLength > LOG_FILE_MAX_SIZE)
{
Console.WriteLine(" -------------- Rolling over log ----------------------- ");
CloseLogger();
InitLogger(Logger.LogFilePrefix);
}
}
finally
{
Loggerlock.ReleaseWriterLock();
}
}
catch (Exception ex)
{
throw ex;
}
return(finalString);
}
private void InitFunctions()
{
if (!initFunctions)
{
@lock.AcquireWriterLock(-1);
try
{
if (!initFunctions)
{
if (contextType != typeof(DataContext))
{
for (Type type = contextType; type != typeof(DataContext); type = type.BaseType)
{
foreach (MethodInfo info in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
if (IsUserFunction(info))
{
if (info.IsGenericMethodDefinition)
{
throw Error.InvalidUseOfGenericMethodAsMappedFunction(info.Name);
}
var key = new MetaPosition(info);
if (!metaFunctions.ContainsKey(key))
{
MetaFunction function = new AttributedMetaFunction(this, info, attributeProvider);
metaFunctions.Add(key, function);
foreach (MetaType type2 in function.ResultRowTypes)
{
foreach (MetaType type3 in type2.InheritanceTypes)
{
if (!metaTypes.ContainsKey(type3.Type))
{
metaTypes.Add(type3.Type, type3);
}
}
}
}
}
}
}
}
initFunctions = true;
}
}
finally
{
@lock.ReleaseWriterLock();
}
}
}
private void DownloadReport_Click(object sender, EventArgs e)
{
if (ReportName.Text == "")
{
MessageBox.Show("Enter Report Name");
}
else
{
//writing the file in a thread safe manner
//this implementation can be useful when the application grows and wrties to multiple files at once
try
{
locker.AcquireWriterLock(int.MaxValue);
string dateString = DateTime.Today.ToLongDateString();
var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dateString + " - " + ReportName.Text + ".txt");
Transactions transactions = new Transactions();
var data = transactions.GetReportData(ReportStartDate.Value, ReportEndDate.Value);
StreamWriter tw = File.AppendText(fileName);
foreach (DataRow row in data.Rows)
{
string id = row["transaction_id"].ToString();
string name = row["name"].ToString();
string type = row["type"].ToString();
string amount = row["amount"].ToString();
string description = row["description"].ToString();
string date = row["transaction_date"].ToString();
string payment_type = row["payment_type"].ToString();
tw.Write(id);
tw.Write(", " + name);
tw.Write(", " + type);
tw.Write(", " + amount);
tw.Write(", " + description);
tw.Write(", " + date);
tw.Write(", " + payment_type);
tw.Write("\n");
}
tw.Close();
MessageBox.Show("Report Generate Successfully!\nSaved At: " + fileName);
ReportName.Text = "";
}
finally
{
locker.ReleaseReaderLock();
}
}
}
public AutoLock(ReaderWriterLock l, bool forWrite)
{
this.l = l;
if (this.forWrite = forWrite)
l.AcquireWriterLock(timeout);
else
l.AcquireReaderLock(timeout);
}
public static void InvalidTimeoutTest_ChangedInDotNetCore()
{
var rwl = new ReaderWriterLock();
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.AcquireReaderLock(-2));
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.AcquireReaderLock(TimeSpan.FromMilliseconds(-2)));
Assert.Throws<ArgumentOutOfRangeException>(
() => rwl.AcquireReaderLock(TimeSpan.FromMilliseconds((uint)int.MaxValue + 1)));
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.AcquireWriterLock(-2));
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.AcquireWriterLock(TimeSpan.FromMilliseconds(-2)));
Assert.Throws<ArgumentOutOfRangeException>(
() => rwl.AcquireWriterLock(TimeSpan.FromMilliseconds((uint)int.MaxValue + 1)));
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.UpgradeToWriterLock(-2));
Assert.Throws<ArgumentOutOfRangeException>(() => rwl.UpgradeToWriterLock(TimeSpan.FromMilliseconds(-2)));
Assert.Throws<ArgumentOutOfRangeException>(
() => rwl.UpgradeToWriterLock(TimeSpan.FromMilliseconds((uint)int.MaxValue + 1)));
}
