public static Command DoActionWithReaderLock(Func <Command> funcToRun)
{
Command found = null;
bool hadLock = false;
if (_lock.IsWriterLockHeld || _lock.IsReaderLockHeld)
{
//use it;
hadLock = true;
}
else
{
_lock.AcquireReaderLock(_writerLockTimeoutMs);
}
if (!_lock.IsReaderLockHeld)
{
throw new ApplicationException("Unable to acquire Reader lock on CommandQueue (to return single) after waiting " + _writerLockTimeoutMs + " milliseconds.");
}
//do the thing
found = funcToRun();
if (hadLock)
{
//keep it
}
else
{
//Reset the
_lock.ReleaseReaderLock();
}
return(found);
}
/// <summary>
/// Returns the System Defaults as a Typed DataTable.
/// <para>
/// The caller doesn't need to know whether the Cache is already populated - if
/// this should be necessary, this function will make a request to populate the
/// cache.
/// </para>
/// </summary>
/// <returns>System Defaults as a Typed DataTable.</returns>
public SSystemDefaultsTable GetSystemDefaultsTable()
{
SSystemDefaultsTable ReturnValue;
// Obtain thread-safe access to the FTableCached Field to prevent two (or more) Threads from getting a different
// FTableCached value!
lock (FTableCachedLockCookie)
{
if (!FTableCached)
{
LoadSystemDefaultsTable();
FTableCached = true;
}
}
try
{
/*
* Try to get a read lock on the cache table [We don't specify a timeout because
* (1) reading an emptied cache would lead to problems (it is emptied before the DB queries are issued),
* (2) reading the DB tables into the cached table should be fairly quick]
*/
FReadWriteLock.AcquireReaderLock(SharedConstants.THREADING_WAIT_INFINITE);
ReturnValue = FSystemDefaultsDT;
}
finally
{
// Release read lock on the cache table
FReadWriteLock.ReleaseReaderLock();
}
return(ReturnValue);
}
/// <summary>
/// Returns the System Defaults as a Typed DataTable.
///
/// The caller doesn't need to know whether the Cache is already populated - if
/// this should be necessary, this function will make a request to populate the
/// cache.
///
/// </summary>
/// <returns>System Defaults as a Typed DataTable.
/// </returns>
public SSystemDefaultsTable GetSystemDefaultsTable()
{
SSystemDefaultsTable ReturnValue;
if (!FTableCached)
{
LoadSystemDefaultsTable();
FTableCached = true;
}
try
{
/*
* Try to get a read lock on the cache table [We don't specify a timeout because
* (1) reading an emptied cache would lead to problems (it is emptied before the DB queries are issued),
* (2) reading the DB tables into the cached table should be fairly quick]
*/
FReadWriteLock.AcquireReaderLock(SharedConstants.THREADING_WAIT_INFINITE);
ReturnValue = FSystemDefaultsDT;
}
finally
{
// Release read lock on the cache table
FReadWriteLock.ReleaseReaderLock();
}
return(ReturnValue);
}
//获取告警字符串
public CommandMsgV2 ConvertToMsg()
{
try
{
SyncRoot.AcquireReaderLock(-1);
CommandMsgV2 msg = new CommandMsgV2();
msg.TK_CommandType = Constants.TK_CommandType.ALARM_REPORT;
msg.SeqID = CommandProcessor.AllocateID();
msg.SetValue("集中告警流水号", TKSn.ToString());
msg.SetValue("厂商告警流水号", ManuSn);
msg.SetValue("告警城市", City);
msg.SetValue("设备厂商", Manufacturer);
msg.SetValue("业务类型", BusinessType);
msg.SetValue("网元名称", NeName);
msg.SetValue("网元类型", NeType);
msg.SetValue("对象名称", ObjName);
msg.SetValue("对象类型", ObjType);
msg.SetValue("告警名称", AlarmName);
msg.SetValue("重定义告警名称", Redefinition);
//msg.SetValue("告警种类", Category);
msg.SetValue("告警级别", Severity);
msg.SetValue("告警发生时间", OccurTime);
msg.SetValue("告警确认时间LV1", AckTimeLV1);
msg.SetValue("再次确认时间LV1", AckAgainTimeLV1);
msg.SetValue("告警确认时间LV2", AckTimeLV2);
msg.SetValue("再次确认时间LV2", AckAgainTimeLV2);
msg.SetValue("告警恢复时间", ClearTime);
msg.SetValue("告警定位信息", Location);
msg.SetValue("操作员信息LV11", OperatorLV11);
msg.SetValue("操作员信息LV12", OperatorLV12);
msg.SetValue("操作员信息LV21", OperatorLV21);
msg.SetValue("操作员信息LV22", OperatorLV22);
msg.SetValue("工程上报信息", ProjectInfo);
msg.SetValue("派单人LV1", OrderOperatorLV1);
msg.SetValue("派单号LV1", OrderIDLV1);
msg.SetValue("派单时间LV1", OrderTimeLV1);
msg.SetValue("派单人LV2", OrderOperatorLV2);
msg.SetValue("派单号LV2", OrderIDLV2);
msg.SetValue("派单时间LV2", OrderTimeLV2);
msg.SetValue("OMCName", OMCName);
msg.SetValue("Reserved2", Reserved2);
msg.SetValue("Reserved3", Reserved3);
msg.SetValue("接收时间", ReceiveTime);
msg.SetValue("工程超时", ProjectTimeOut);
return(msg);
}
finally
{
SyncRoot.ReleaseReaderLock();
}
}
/// <summary>
/// Gets the element.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="category">The category.</param>
/// <param name="culture">The culture.</param>
/// <returns></returns>
public Element GetElement(string name, string category, string culture)
{
locker.AcquireReaderLock(Timeout.Infinite);
try
{
string filePath = Path.Combine(this.path, ResXResourceFileHelper.GetFileName(category, culture));
XDocument document = GetResxDocument(filePath);
if (document == null)
{
return(null);
}
return(document.Root.Elements("data")
.Where(it => it.Attribute("name").Value.EqualsOrNullEmpty(name, StringComparison.OrdinalIgnoreCase))
.Select(it => new Element()
{
Name = it.Attribute("name").Value,
Value = it.Element("value").Value,
Category = category,
Culture = culture
}).FirstOrDefault());
}
finally
{
locker.ReleaseReaderLock();
}
}
public static int GetGPRate()
{
m_lock.AcquireReaderLock(Timeout.Infinite);
int rate = 1;
try
{
if (_RateInfo.Rate == -1)
{
return(1);
}
if (_RateInfo.BeginDay != null && _RateInfo.EndDay != null)
{
if (_RateInfo.BeginDay.Year <= DateTime.Now.Year && DateTime.Now.Year <= _RateInfo.EndDay.Year)
{
if (_RateInfo.BeginDay.DayOfYear <= DateTime.Now.DayOfYear && DateTime.Now.DayOfYear <= _RateInfo.EndDay.DayOfYear)
{
if (_RateInfo.BeginTime.TimeOfDay <= DateTime.Now.TimeOfDay && DateTime.Now.TimeOfDay <= _RateInfo.EndTime.TimeOfDay)
{
rate = _RateInfo.Rate;
}
}
}
}
}
catch { }
finally
{
m_lock.ReleaseReaderLock();
}
return(rate);
}
internal OletxResourceManager FindOrRegisterResourceManager(
Guid resourceManagerIdentifier
)
{
if (resourceManagerIdentifier == Guid.Empty)
{
throw new ArgumentException(SR.GetString(SR.BadResourceManagerId), "resourceManagerIdentifier");
}
OletxResourceManager oletxResourceManager = null;
resourceManagerHashTableLock.AcquireReaderLock(-1);
try
{
oletxResourceManager = resourceManagerHashTable[resourceManagerIdentifier] as OletxResourceManager;
}
finally
{
resourceManagerHashTableLock.ReleaseReaderLock();
}
if (null == oletxResourceManager)
{
return(RegisterResourceManager(resourceManagerIdentifier));
}
return(oletxResourceManager);
}
/// <summary>
/// 获取游戏倍率
/// </summary>
/// <param name="eType">倍率类型</param>
/// <returns></returns>
public static float GetRate(eRateType eType)
{
float rate = 1;
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
RateInfo _RateInfo = GetRateInfoWithType((int)eType);
if (_RateInfo == null)
{
return(rate);
}
if (_RateInfo.Rate == 0)
{
return(1);
}
if (IsValid(_RateInfo))
{
rate = _RateInfo.Rate;
}
}
catch { }
finally
{
m_lock.ReleaseReaderLock();
}
return(rate);
}
public void TestIsReaderLockHeld ()
{
rwlock = new ReaderWriterLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld, "#1");
rwlock.AcquireReaderLock (500);
Assert.IsTrue (rwlock.IsReaderLockHeld, "#1");
RunThread (new ThreadStart (IsReaderLockHeld_2));
rwlock.ReleaseReaderLock ();
}
public static StrengthenInfo FindStrengthenInfo(int level)
{
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_strengthens.ContainsKey(level))
{
return(_strengthens[level]);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
public void TestIsReaderLockHeld ()
{
rwlock = new ReaderWriterLock ();
Assert ("a1", !rwlock.IsReaderLockHeld);
rwlock.AcquireReaderLock (500);
Assert ("a2", rwlock.IsReaderLockHeld);
RunThread (new ThreadStart (IsReaderLockHeld_2));
rwlock.ReleaseReaderLock ();
}
public static BallInfo FindBall(int GoodsID)
{
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_balls.ContainsKey(GoodsID))
{
return(_balls[GoodsID]);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(_balls[0]);
}
public System.Drawing.Image GetCameraFrameAndState(ref PSMoveSharpState state)
{
System.Drawing.Image image;
camera_frame_state_rwl.AcquireReaderLock(-1);
state = camera_frame_state_collector.GetCompleteState();
image = (System.Drawing.Image)camera_frame_state_collector.GetCompleteImage().Clone();
camera_frame_state_rwl.ReleaseReaderLock();
return(image);
}
public List <byte[]> GetCameraFrameAndState(ref PSMoveSharpState state)
{
List <byte[]> image;
camera_frame_state_rwl.AcquireReaderLock(-1);
state = camera_frame_state_collector.GetCompleteState();
image = camera_frame_state_collector.GetCompleteImage();
camera_frame_state_rwl.ReleaseReaderLock();
return(image);
}
public static ItemTemplateInfo FindAllProp(int id)
{
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_allProp.ContainsKey(id))
{
return(_allProp[id]);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
public static ConsortiaInfo FindConsortiaInfo(int consortiaID)
{
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_consortia.ContainsKey(consortiaID))
{
return(_consortia[consortiaID]);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
public void DoSth9()
{
try
{
myReaderWriterLock.AcquireReaderLock(1000);
}
finally
{
myReaderWriterLock.ReleaseReaderLock();
}
}
public static ItemTemplateInfo FindItemTemplate(int templateId)
{
if (_items == null)
{
Init();
}
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_items.Keys.Contains(templateId))
{
return(_items[templateId]);
}
}
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
void m_TimerMaintenance_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
if (Interlocked.Exchange(ref m_InMaintenanceTimer, 1) == 1)
{
return;
}
try
{
m_StopPrivilege.AcquireReaderLock(-1);
DateTime now = DateTime.Now;
if (now.Hour != 3)
{
return;
}
string[] logfiles = System.IO.Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + "log" + Path.DirectorySeparatorChar, "*_log.txt");
foreach (string file in logfiles)
{
try
{
DateTime t = System.IO.File.GetCreationTime(file);
TimeSpan span = now - t;
if (span.TotalDays > 7)
{
System.IO.File.Delete(file);
}
ClearNMAlarm(Name, Constants.MO_PROCESS, Constants.TKALM_PROCESSALM, DateTime.Now);
}
catch (Exception ex)
{
RaiseNMAlarm(Name, Constants.MO_PROCESS, Constants.TKALM_PROCESSALM, ex.Message, DateTime.Now);
SendLog(ex.ToString());
}
if (PendingRunFlag == 0)
{
return;
}
}
}
finally
{
m_StopPrivilege.ReleaseReaderLock();
Interlocked.Exchange(ref m_InMaintenanceTimer, 0);
}
}
private static void MacroDropSync()
{
bool syncMacroDrop = true;
ServerClient[] serverClients = CenterServer.Instance.GetAllClients();
foreach (ServerClient serverClient in serverClients)
{
if (!serverClient.NeedSyncMacroDrop)
{
syncMacroDrop = false;
break;
}
}
if (serverClients.Length > 0 && syncMacroDrop)
{
GSPacketIn pkg = new GSPacketIn((byte)ePackageType.MACRO_DROP);
int count = m_DropInfo.Count;
pkg.WriteInt(count);
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
foreach (KeyValuePair <int, DropInfo> kvp in m_DropInfo)
{
DropInfo di = kvp.Value;
pkg.WriteInt(di.ID);
pkg.WriteInt(di.Count);
pkg.WriteInt(di.MaxCount);
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("DropInfoMgr MacroDropReset", e);
}
}
finally
{
m_lock.ReleaseReaderLock();
}
foreach (ServerClient serverClient in serverClients)
{
serverClient.NeedSyncMacroDrop = false;
serverClient.SendTCP(pkg);
}
}
}
public static DailyAwardInfo[] GetAllAwardInfo()
{
DailyAwardInfo[] infos = null;
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
infos = _dailyAward.Values.ToArray();
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(infos == null ? new DailyAwardInfo[0] : infos);
}
public static FightRateInfo[] GetAllFightRateInfo()
{
FightRateInfo[] infos = null;
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
infos = _fightRate.Values.ToArray();
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(infos == null ? new FightRateInfo[0] : infos);
}
public static ConsortiaLevelInfo FindConsortiaLevelInfo(int level)
{
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_consortiaLevel.ContainsKey(level))
{
return(_consortiaLevel[level]);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
// Update is called once per frame
void Update()
{
Queue <string> post = new Queue <string>();
inLock.AcquireReaderLock(100);
while (eventQueue.Count > 0)
{
post = eventQueue.Dequeue();
gameObject.SendMessage(post.Dequeue(), post.Dequeue());
}
while (messages.Count > outText.Count)
{
messages.Dequeue();
}
for (int i = 0; i < messages.Count; ++i)
{
outText[i].text = messages.ToArray()[i];
}
inLock.ReleaseReaderLock();
}
/// <summary>
/// 多线程安全缓存参数类型集合
/// </summary>
private PropertyInfo[] GetCacheParamType <T>(T pb)
{
Type pbtype = pb.GetType();
try
{
if (cacheParamType.ContainsKey(pbtype))
{
return(cacheParamType[pbtype]);
}
else
{
lockrw.AcquireWriterLock(1000);
if (!cacheParamType.ContainsKey(pbtype))
{
PropertyInfo[] pis = pbtype.GetProperties().OrderBy(p => p.Name).ToArray();
cacheParamType.Add(pbtype, pis);
return(pis);
}
else
{
return(cacheParamType[pbtype]);
}
}
}
finally
{
if (lockrw.IsReaderLockHeld)
{
lockrw.ReleaseReaderLock();
}
if (lockrw.IsWriterLockHeld)
{
lockrw.ReleaseWriterLock();
}
}
}
public void ReaderWriter_WhenUpgradedWriteLockReleased_EdgesDeleteFromGraph()
{
ReaderWriterLock rwl = new ReaderWriterLock();
Barrier barrier = new Barrier(3);
Barrier barrier2 = new Barrier(3);
Task t1 = new Task(() =>
{
rwl.AcquireReaderLock(Timeout.Infinite);
rwl.UpgradeToWriterLock(Timeout.Infinite);
rwl.ReleaseWriterLock();
barrier.SignalAndWait();
barrier2.SignalAndWait();
lock (rwl)
{
Thread.Sleep(100);
}
});
Task t2 = new Task(() =>
{
barrier.SignalAndWait();
lock (rwl)
{
barrier2.SignalAndWait();
rwl.AcquireWriterLock(Timeout.Infinite);
}
});
t1.Start();
t2.Start();
barrier.SignalAndWait();
rwl.AcquireReaderLock(Timeout.Infinite);
barrier2.SignalAndWait();
Thread.Sleep(500);
rwl.ReleaseReaderLock();
Task.WaitAll(new[] { t1, t2 });
}
public void DowngradeTest ()
{
LockCookie lc1, lc2, lc3, lc4;
rwlock = new ReaderWriterLock ();
rwlock.AcquireReaderLock (Timeout.Infinite);
lc1 = rwlock.UpgradeToWriterLock (Timeout.Infinite);
rwlock.AcquireReaderLock (Timeout.Infinite);
lc2 = rwlock.UpgradeToWriterLock (Timeout.Infinite);
rwlock.AcquireReaderLock (Timeout.Infinite);
lc3 = rwlock.UpgradeToWriterLock (Timeout.Infinite);
rwlock.AcquireReaderLock (Timeout.Infinite);
lc4 = rwlock.UpgradeToWriterLock (Timeout.Infinite);
rwlock.DowngradeFromWriterLock (ref lc2);
Assert.IsFalse (rwlock.IsReaderLockHeld, "A1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "A2");
rwlock.ReleaseReaderLock ();
Assert.IsFalse (rwlock.IsReaderLockHeld, "B1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "B2");
rwlock.DowngradeFromWriterLock (ref lc4);
Assert.IsFalse (rwlock.IsReaderLockHeld, "C1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "C2");
rwlock.ReleaseReaderLock ();
Assert.IsFalse (rwlock.IsReaderLockHeld, "D1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "D2");
rwlock.DowngradeFromWriterLock (ref lc3);
Assert.IsFalse (rwlock.IsReaderLockHeld, "E1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "E2");
rwlock.ReleaseReaderLock ();
Assert.IsFalse (rwlock.IsReaderLockHeld, "F1");
Assert.IsTrue (rwlock.IsWriterLockHeld, "F2");
rwlock.DowngradeFromWriterLock (ref lc1);
Assert.IsTrue (rwlock.IsReaderLockHeld, "G1");
Assert.IsFalse (rwlock.IsWriterLockHeld, "G2");
rwlock.ReleaseReaderLock ();
Assert.IsFalse (rwlock.IsReaderLockHeld, "H1");
Assert.IsFalse (rwlock.IsWriterLockHeld, "H2");
}
/// <summary>
/// Executes a job on demand, rather than waiting for its regularly scheduled time.
/// </summary>
/// <param name="job">The job to be executed.</param>
public static void ExecuteJob(JobBase job)
{
ReaderWriterLock rwLock = new ReaderWriterLock();
try
{
rwLock.AcquireReaderLock(Timeout.Infinite);
if (job.Executing == false)
{
LockCookie lockCookie = rwLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
if (job.Executing == false)
{
job.Executing = true;
QueueJob(job);
}
}
finally
{
rwLock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
rwLock.ReleaseReaderLock();
}
}
//- @GetWebDomainData -//
/// <summary>
/// Returns the WebDomainData object for a particular web domain.
/// </summary>
/// <param name="webDomainName">The web domain name used to lookup the web domain.</param>
/// <returns>A WebDomainData object or null if the web domain name is invalid.</returns>
public static WebDomainData GetWebDomainData(String webDomainName)
{
var readerWriterLock = new ReaderWriterLock();
readerWriterLock.AcquireReaderLock(Timeout.Infinite);
try
{
if (String.IsNullOrEmpty(webDomainName))
{
webDomainName = "root";
}
//+
return WebDomainDataList.AllWebDomainData.SingleOrDefault(p => p.Name == webDomainName);
}
finally
{
readerWriterLock.ReleaseReaderLock();
}
}
//
public static ItemTemplateInfo Fusion(List <ItemInfo> Items, List <ItemInfo> AppendItems, ItemInfo Formul, ref bool isBind, ref bool result)
{
List <int> list = new List <int>();
int MaxLevel = 0;
int TotalRate = 0;
//int BindType = 0;
ItemTemplateInfo returnItem = null;
foreach (ItemInfo p in Items)
{
list.Add(p.Template.FusionType);
if (p.Template.Level > MaxLevel)
{
MaxLevel = p.Template.Level;
}
TotalRate += p.Template.FusionRate;
if (p.IsBinds)
{
isBind = true;
}
}
if (Formul.IsBinds)
{
isBind = true;
}
foreach (ItemInfo p in AppendItems)
{
TotalRate += p.Template.FusionRate / 2;
if (p.IsBinds)
{
isBind = true;
}
}
list.Sort();
StringBuilder itemString = new StringBuilder();
foreach (int i in list)
{
itemString.Append(i);
}
itemString.Append(Formul.TemplateID);
string key = itemString.ToString();
m_lock.AcquireReaderLock(Timeout.Infinite);
try
{
if (_fusions.ContainsKey(key))
{
FusionInfo info = _fusions[key];
double rateMax = 0;
double rateMin = 0;
ItemTemplateInfo temp_0 = Bussiness.Managers.ItemMgr.GetGoodsbyFusionTypeandLevel(info.Reward, MaxLevel);
ItemTemplateInfo temp_1 = Bussiness.Managers.ItemMgr.GetGoodsbyFusionTypeandLevel(info.Reward, MaxLevel + 1);
ItemTemplateInfo temp_2 = Bussiness.Managers.ItemMgr.GetGoodsbyFusionTypeandLevel(info.Reward, MaxLevel + 2);
List <ItemTemplateInfo> temps = new List <ItemTemplateInfo>();
if (temp_2 != null)
{
temps.Add(temp_2);
}
if (temp_1 != null)
{
temps.Add(temp_1);
}
if (temp_0 != null)
{
temps.Add(temp_0);
}
ItemTemplateInfo tempMax = temps.Where(s => (TotalRate / (double)s.FusionNeedRate) <= 1.1).OrderByDescending(s => (TotalRate / (double)s.FusionNeedRate)).FirstOrDefault();
ItemTemplateInfo tempMin = temps.Where(s => (TotalRate / (double)s.FusionNeedRate) > 1.1).OrderBy(s => (TotalRate / (double)s.FusionNeedRate)).FirstOrDefault();
if ((tempMax != null) && (tempMin == null))
{
returnItem = tempMax;
result = true;
}
if ((tempMax != null) && (tempMin != null))
{
if (tempMax.Level - tempMin.Level == 2)
{
rateMax = 100 * TotalRate * 0.6 / (double)tempMax.FusionNeedRate;
rateMin = 100 - rateMax;
}
else
{
rateMax = 100 * TotalRate / (double)tempMax.FusionNeedRate;
rateMin = 100 - rateMax;
}
if (100 * TotalRate / (double)tempMax.FusionNeedRate > rand.Next(100))
{
returnItem = tempMax;
result = true;
}
else
{
returnItem = tempMin;
result = true;
}
}
if ((tempMax == null) && (tempMin != null))
{
returnItem = tempMin;
result = true;
}
if (result)
{
foreach (ItemInfo p in Items)
{
if (p.Template.TemplateID == returnItem.TemplateID)
{
result = false;
break;
}
}
}
return(returnItem);
}
}
catch
{ }
finally
{
m_lock.ReleaseReaderLock();
}
return(null);
}
public void DoSth9()
{
myReaderWriterLock.AcquireReaderLock(1000);
myReaderWriterLock.ReleaseReaderLock();
}
public void TestReleaseRestoreReaderLock ()
{
rwlock = new ReaderWriterLock ();
rwlock.AcquireReaderLock (500);
rwlock.AcquireReaderLock (500);
Assert.IsTrue (rwlock.IsReaderLockHeld);
LockCookie co = rwlock.ReleaseLock ();
RunThread (new ThreadStart (AcquireLock_writerWorks));
rwlock.RestoreLock (ref co);
RunThread (new ThreadStart (AcquireLock_writerFails));
rwlock.ReleaseReaderLock ();
Assert.IsTrue (rwlock.IsReaderLockHeld);
rwlock.ReleaseReaderLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
}
internal virtual RewriteRule FindFirstMatch(HttpApplication app, out string requestUrl, RewriteRuleCollection rules, ReaderWriterLock ruleCollectionLock)
{
requestUrl = null;
RewriteRule matchedRule = null;
ruleCollectionLock.AcquireReaderLock(0);
try
{
foreach (var rule in rules)
{
if ((rule.Rewrite & RewriteOption.Domain) != 0)
requestUrl = app.Request.Url.AbsoluteUri;
else
requestUrl = app.Request.RawUrl;
if (rule.IsRewrite(requestUrl))
{
matchedRule = rule;
break;
}
}
}
finally
{
ruleCollectionLock.ReleaseReaderLock();
}
return matchedRule;
}
/// <summary>
/// Finishes a read operation and allows write operations
/// to begin if no read operations are still being
/// serviced.
/// </summary>
public void EndRead()
{
RWLock.ReleaseReaderLock();
}
/// <summary>
/// Registers a single local event handler.
/// Local event handlers will only be called if the
/// "sender" parameter in the Notify method equals
/// the object for which a local event handler was
/// registered.
/// </summary>
/// <remarks>
/// Certain events will never have a local event handler.
/// This happens if the Notify method is called without
/// a sender parameter for example!
/// </remarks>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <param name="unique">Flag wether event shall be added unique or not</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
private static void AddHandler(object obj, RoadEvent e, RoadEventHandler del, bool unique)
{
//Test the parameters
if (obj == null)
{
throw new ArgumentNullException("obj", "No object given!");
}
if (e == null)
{
throw new ArgumentNullException("e", "No event type given!");
}
if (del == null)
{
throw new ArgumentNullException("del", "No event handler given!");
}
if (!e.IsValidFor(obj))
{
throw new ArgumentException("Object is not valid for this event type", "obj");
}
try
{
m_lock.AcquireReaderLock(TIMEOUT);
try
{
RoadEventHandlerCollection col = (RoadEventHandlerCollection)m_GameObjectEventCollections[obj];
if (col == null)
{
col = new RoadEventHandlerCollection();
LockCookie lc = m_lock.UpgradeToWriterLock(TIMEOUT);
try
{
m_GameObjectEventCollections[obj] = col;
}
finally
{
m_lock.DowngradeFromWriterLock(ref lc);
}
}
if (unique)
{
col.AddHandlerUnique(e, del);
}
else
{
col.AddHandler(e, del);
}
}
finally
{
m_lock.ReleaseReaderLock();
}
}
catch (ApplicationException ex)
{
if (log.IsErrorEnabled)
{
log.Error("Failed to add local event handler!", ex);
}
}
}
public void TestAcquireLocks ()
{
rwlock = new ReaderWriterLock ();
rwlock.AcquireReaderLock (500);
rwlock.AcquireReaderLock (500);
rwlock.ReleaseReaderLock ();
Assert.IsTrue (rwlock.IsReaderLockHeld, "#1");
RunThread (new ThreadStart (AcquireLock_readerWorks));
Assert.IsTrue (rwlock.IsReaderLockHeld);
RunThread (new ThreadStart (AcquireLock_writerFails));
rwlock.ReleaseReaderLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
RunThread (new ThreadStart (AcquireLock_writerWorks));
rwlock.AcquireWriterLock (200);
RunThread (new ThreadStart (AcquireLock_writerFails));
RunThread (new ThreadStart (AcquireLock_readerFails));
rwlock.ReleaseWriterLock ();
}
public void TestUpgradeDowngradeLock ()
{
rwlock = new ReaderWriterLock ();
rwlock.AcquireReaderLock (200);
rwlock.AcquireReaderLock (200);
LockCookie co = rwlock.UpgradeToWriterLock (200);
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (rwlock.IsWriterLockHeld);
RunThread (new ThreadStart (AcquireLock_writerFails));
rwlock.DowngradeFromWriterLock (ref co);
Assert.IsTrue (rwlock.IsReaderLockHeld);
Assert.IsTrue (!rwlock.IsWriterLockHeld);
RunThread (new ThreadStart (AcquireLock_readerWorks));
rwlock.ReleaseReaderLock ();
Assert.IsTrue (rwlock.IsReaderLockHeld);
rwlock.ReleaseReaderLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
}
public void ReaderWriter_When2CycleDetected_DoesNotThrows()
{
ReaderWriterLock rwl = new ReaderWriterLock();
Barrier barrier = new Barrier(2);
Action t1 = () =>
{
rwl.AcquireReaderLock(Timeout.Infinite);
barrier.SignalAndWait();
rwl.UpgradeToWriterLock(Timeout.Infinite);
rwl.ReleaseWriterLock();
};
Action t2 = () =>
{
rwl.AcquireReaderLock(Timeout.Infinite);
barrier.SignalAndWait();
Thread.Sleep(500);
rwl.ReleaseReaderLock();
};
TestHelpers.InvokeSimultaneouslyAndWait(t1, t2);
}
public void TestReaderInsideWriter ()
{
// Reader acquires and releases work like the writer equivalent
rwlock = new ReaderWriterLock ();
rwlock.AcquireWriterLock (-1);
rwlock.AcquireReaderLock (-1);
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (rwlock.IsWriterLockHeld);
rwlock.AcquireReaderLock (-1);
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (rwlock.IsWriterLockHeld);
rwlock.ReleaseWriterLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (rwlock.IsWriterLockHeld);
rwlock.ReleaseReaderLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (rwlock.IsWriterLockHeld);
rwlock.ReleaseReaderLock ();
Assert.IsTrue (!rwlock.IsReaderLockHeld);
Assert.IsTrue (!rwlock.IsWriterLockHeld);
}
// Read from Resource:
static void ShowNumber(object index)
{
readerWriterLock.AcquireReaderLock(1000);
Console.Write(numbers[(int)index] + " ");
readerWriterLock.ReleaseReaderLock();
}
public void TestReaderMustWaitWriter ()
{
// A thread cannot get the reader lock if there are other threads
// waiting for the writer lock.
rwlock = new ReaderWriterLock ();
rwlock.AcquireWriterLock (200);
ThreadRunner tr = StartThread (new ThreadStart (ReaderMustWaitWriter_2));
Thread.Sleep (200);
RunThread (new ThreadStart (AcquireLock_readerFails));
rwlock.ReleaseReaderLock ();
tr.Join ();
}
public void TestReaderInsideWriter ()
{
// Reader acquires and releases work like the writer equivalent
rwlock = new ReaderWriterLock ();
rwlock.AcquireWriterLock (-1);
rwlock.AcquireReaderLock (-1);
Assert ("u1", !rwlock.IsReaderLockHeld);
Assert ("u2", rwlock.IsWriterLockHeld);
rwlock.AcquireReaderLock (-1);
Assert ("u3", !rwlock.IsReaderLockHeld);
Assert ("u4", rwlock.IsWriterLockHeld);
rwlock.ReleaseWriterLock ();
Assert ("u5", !rwlock.IsReaderLockHeld);
Assert ("u6", rwlock.IsWriterLockHeld);
rwlock.ReleaseReaderLock ();
Assert ("u7", !rwlock.IsReaderLockHeld);
Assert ("u8", rwlock.IsWriterLockHeld);
rwlock.ReleaseReaderLock ();
Assert ("u9", !rwlock.IsReaderLockHeld);
Assert ("u10", !rwlock.IsWriterLockHeld);
}
public void TestBug_55911 ()
{
rwlock = new ReaderWriterLock ();
rwlock.AcquireReaderLock (Timeout.Infinite);
try {
LockCookie lc = rwlock.UpgradeToWriterLock (Timeout.Infinite);
}
finally { rwlock.ReleaseReaderLock(); }
rwlock.AcquireReaderLock (Timeout.Infinite);
try {
LockCookie lc = rwlock.UpgradeToWriterLock (Timeout.Infinite);
}
finally { rwlock.ReleaseReaderLock(); }
}
/// <summary>
/// Removes all objects in the specified cache context.
/// </summary>
/// <param name="context">The cache context to clear.</param>
/// <returns>False if the context does not exist, true otherwise.</returns>
public static bool ClearContext(string context)
{
bool retval = true;
readWriteLock.AcquireReaderLock(MAX_LOCK_WAIT);
try
{
if (caches.ContainsKey(context))
{
caches[context].Clear();
}
else
{
retval = false;
}
}
finally
{
readWriteLock.ReleaseReaderLock();
}
return(retval);
}
public void TestBug_55909 ()
{
rwlock = new ReaderWriterLock ();
ThreadRunner tr = StartThread (new ThreadStart(Bug_55909_Thread2));
Thread.Sleep (200);
rwlock.AcquireReaderLock (Timeout.Infinite);
try {
LockCookie lc = rwlock.UpgradeToWriterLock (Timeout.Infinite);
Thread.Sleep (500);
}
finally { rwlock.ReleaseReaderLock(); }
tr.Join ();
}
public static IDisposable AcquireReaderLock(ReaderWriterLock rwl)
{
rwl.AcquireReaderLock(Timeout.Infinite);
return new Disposer(() => rwl.ReleaseReaderLock());
}
//获取告警字符串
public string GetAlarmString()
{
try
{
SyncRoot.AcquireReaderLock(-1);
System.Text.StringBuilder alarmstring = new System.Text.StringBuilder();
alarmstring.Append("<++++>\r\n");
alarmstring.Append("COMMAND = ADAPTER_ALARM_REPORT\r\n");
alarmstring.Append("集中告警流水号 = ");
alarmstring.Append(TKSn);
alarmstring.Append("\r\n");
alarmstring.Append("厂商告警流水号 = ");
alarmstring.Append(ManuSn);
alarmstring.Append("\r\n");
alarmstring.Append("告警城市 = ");
alarmstring.Append(City);
alarmstring.Append("\r\n");
alarmstring.Append("设备厂商 = ");
alarmstring.Append(Manufacturer);
alarmstring.Append("\r\n");
alarmstring.Append("业务类型 = ");
alarmstring.Append(BusinessType);
alarmstring.Append("\r\n");
alarmstring.Append("网元名称 = ");
alarmstring.Append(NeName);
alarmstring.Append("\r\n");
alarmstring.Append("网元类型 = ");
alarmstring.Append(NeType);
alarmstring.Append("\r\n");
alarmstring.Append("对象名称 = ");
alarmstring.Append(ObjName);
alarmstring.Append("\r\n");
alarmstring.Append("对象类型 = ");
alarmstring.Append(ObjType);
alarmstring.Append("\r\n");
alarmstring.Append("告警名称 = ");
alarmstring.Append(AlarmName);
alarmstring.Append("\r\n");
alarmstring.Append("重定义告警名称 = ");
alarmstring.Append(Redefinition);
alarmstring.Append("\r\n");
//alarmstring.Append("告警种类 = ");
//alarmstring.Append(Category);
//alarmstring.Append("\r\n");
alarmstring.Append("告警级别 = ");
alarmstring.Append(Severity);
alarmstring.Append("\r\n");
alarmstring.Append("告警发生时间 = ");
alarmstring.Append(OccurTime);
alarmstring.Append("\r\n");
alarmstring.Append("告警确认时间LV1 = ");
alarmstring.Append(AckTimeLV1);
alarmstring.Append("\r\n");
alarmstring.Append("再次确认时间LV1 = ");
alarmstring.Append(AckAgainTimeLV1);
alarmstring.Append("\r\n");
alarmstring.Append("告警确认时间LV2 = ");
alarmstring.Append(AckTimeLV2);
alarmstring.Append("\r\n");
alarmstring.Append("再次确认时间LV2 = ");
alarmstring.Append(AckAgainTimeLV2);
alarmstring.Append("\r\n");
alarmstring.Append("告警恢复时间 = ");
alarmstring.Append(ClearTime);
alarmstring.Append("\r\n");
alarmstring.Append("告警定位信息 = ");
alarmstring.Append(Location);
alarmstring.Append("\r\n");
alarmstring.Append("操作员信息LV11 = ");
alarmstring.Append(OperatorLV11);
alarmstring.Append("\r\n");
alarmstring.Append("操作员信息LV12 = ");
alarmstring.Append(OperatorLV12);
alarmstring.Append("\r\n");
alarmstring.Append("操作员信息LV21 = ");
alarmstring.Append(OperatorLV21);
alarmstring.Append("\r\n");
alarmstring.Append("操作员信息LV22 = ");
alarmstring.Append(OperatorLV22);
alarmstring.Append("\r\n");
alarmstring.Append("工程上报信息 = ");
alarmstring.Append(ProjectInfo);
alarmstring.Append("\r\n");
alarmstring.Append("工程超时 = ");
alarmstring.Append(ProjectBool);
alarmstring.Append("\r\n");
alarmstring.Append("派单人LV1 = ");
alarmstring.Append(OrderOperatorLV1);
alarmstring.Append("\r\n");
alarmstring.Append("派单号LV1 = ");
alarmstring.Append(OrderIDLV1);
alarmstring.Append("\r\n");
alarmstring.Append("派单时间LV1 = ");
alarmstring.Append(OrderTimeLV1);
alarmstring.Append("\r\n");
alarmstring.Append("派单人LV2 = ");
alarmstring.Append(OrderOperatorLV2);
alarmstring.Append("\r\n");
alarmstring.Append("派单号LV2 = ");
alarmstring.Append(OrderIDLV2);
alarmstring.Append("\r\n");
alarmstring.Append("派单时间LV2 = ");
alarmstring.Append(OrderTimeLV2);
alarmstring.Append("\r\n");
alarmstring.Append("OMCName = ");
alarmstring.Append(OMCName);
alarmstring.Append("\r\n");
alarmstring.Append("Reserved2 = ");
alarmstring.Append(Reserved2);
alarmstring.Append("\r\n");
alarmstring.Append("Reserved3 = ");
alarmstring.Append(Reserved3);
alarmstring.Append("\r\n");
alarmstring.Append("接收时间 = ");
alarmstring.Append(ReceiveTime);
alarmstring.Append("\r\n");
alarmstring.Append("<---->\r\n");
return(alarmstring.ToString());
}
finally
{
SyncRoot.ReleaseReaderLock();
}
}
