/// <summary>Increment the reference count.</summary>
/// <exception cref="ClosedChannelException">If the status is closed.</exception>
public virtual void Reference()
{
int curBits = status.IncrementAndGet();
if ((curBits & StatusClosedMask) != 0)
{
status.DecrementAndGet();
throw new ClosedChannelException();
}
}
public bool TryAcquire()
{
int count = UsedCount.IncrementAndGet();
if (count > Count)
{
UsedCount.DecrementAndGet();
return(false);
}
return(true);
}
/// <summary>
/// Expert: decreases the refCount of this TaxonomyReader instance. If the
/// refCount drops to 0 this taxonomy reader is closed.
/// </summary>
public void DecRef()
{
EnsureOpen();
int rc = refCount.DecrementAndGet();
if (rc == 0)
{
bool success = false;
try
{
DoClose();
closed = true;
success = true;
}
finally
{
if (!success)
{
// Put reference back on failure
refCount.IncrementAndGet();
}
}
}
else if (rc < 0)
{
throw new ThreadStateException("too many decRef calls: refCount is " + rc + " after decrement");
}
}
public void test02()
{
var a = new AtomicInteger(1);
Assert.AreEqual(0, a.DecrementAndGet());
Assert.AreEqual(0, a.Value);
}
public override void Run()
{
try
{
long ramSize = 0;
while (PendingDocs.DecrementAndGet() > -1)
{
Document doc = Docs.NextDoc();
Writer.AddDocument(doc);
long newRamSize = Writer.RamSizeInBytes();
if (newRamSize != ramSize)
{
ramSize = newRamSize;
}
if (DoRandomCommit)
{
if (Rarely())
{
Writer.Commit();
}
}
}
Writer.Commit();
}
catch (Exception ex)
{
Console.WriteLine("FAILED exc:");
Console.WriteLine(ex.StackTrace);
throw new Exception(ex.Message, ex);
}
}
public override void Run()
{
Random random = Random();
while (numCats.DecrementAndGet() > 0)
{
try
{
int value = random.Next(range);
FacetLabel cp = new FacetLabel(Convert.ToString(value / 1000), Convert.ToString(value / 10000), Convert.ToString(value / 100000), Convert.ToString(value));
int ord = tw.AddCategory(cp);
Assert.True(tw.GetParent(ord) != -1, "invalid parent for ordinal " + ord + ", category " + cp);
string l1 = FacetsConfig.PathToString(cp.Components, 1);
string l2 = FacetsConfig.PathToString(cp.Components, 2);
string l3 = FacetsConfig.PathToString(cp.Components, 3);
string l4 = FacetsConfig.PathToString(cp.Components, 4);
values[l1] = l1;
values[l2] = l2;
values[l3] = l3;
values[l4] = l4;
}
catch (IOException e)
{
throw new Exception(e.Message, e);
}
}
}
internal virtual Future <int> SubmitRecycle(byte[] array)
{
count.DecrementAndGet();
Future <int> f = pool.Submit(new _Callable_487(this, array));
return(f);
}
/// <summary>Notify the monitor a worker is finished.</summary>
/// <remarks>Notify the monitor a worker is finished.</remarks>
public virtual void EndWorker()
{
if (workers.DecrementAndGet() == 0)
{
process.Release();
}
}
public override void Run()
{
Random random = Random();
while (numDocs.DecrementAndGet() > 0)
{
try
{
Document doc = new Document();
int numCats = random.Next(3) + 1; // 1-3
while (numCats-- > 0)
{
FacetField ff = NewCategory();
doc.Add(ff);
FacetLabel label = new FacetLabel(ff.dim, ff.path);
// add all prefixes to values
int level = label.Length;
while (level > 0)
{
string s = FacetsConfig.PathToString(label.Components, level);
values[s] = s;
--level;
}
}
iw.AddDocument(config.Build(tw, doc));
}
catch (IOException e)
{
throw new Exception(e.Message, e);
}
}
}
internal void MarkCommandDone(ExecutionResult executionResult, IHystrixCommandKey commandKey, IHystrixThreadPoolKey threadPoolKey, bool executionStarted)
{
HystrixThreadEventStream.GetInstance().ExecutionDone(executionResult, commandKey, threadPoolKey);
if (executionStarted)
{
_concurrentExecutionCount.DecrementAndGet();
}
}
/**
* 关闭数据库
*/
public void closeDatabase()
{
if (mOpenCounter.DecrementAndGet() == 0)
{
// Closing database
mDatabase.Close();
}
}
protected void onAcknowledge(Acknowledgement acknowledgement)
{
try
{
waitForAckLatch.Get().CountDown();
waitForSeqAckLatch.Get().CountDown();
CongestionControl cc = session.getCongestionControl();
long rtt = acknowledgement.getRoundTripTime();
if (rtt > 0)
{
long rttVar = acknowledgement.getRoundTripTimeVar();
cc.setRTT(rtt, rttVar);
statistics.setRTT(rtt, rttVar);
}
long rate = acknowledgement.getPacketReceiveRate();
if (rate > 0)
{
long linkCapacity = acknowledgement.getEstimatedLinkCapacity();
cc.updatePacketArrivalRate(rate, linkCapacity);
statistics.setPacketArrivalRate(cc.getPacketArrivalRate(), cc.getEstimatedLinkCapacity());
}
long ackNumber = acknowledgement.getAckNumber();
cc.onACK(ackNumber);
statistics.setCongestionWindowSize((long)cc.getCongestionWindowSize());
//need to remove all sequence numbers up the ack number from the sendBuffer
bool removed = false;
for (long s = lastAckSequenceNumber; s < ackNumber; s++)
{
lock (sendLock)
{
removed = sendBuffer.Remove(s);
}
if (removed)
{
unacknowledged.DecrementAndGet();
}
}
lastAckSequenceNumber = (int)Math.Max(lastAckSequenceNumber, ackNumber);
//send ACK2 packet to the receiver
sendAck2(ackNumber);
statistics.incNumberOfACKReceived();
if (storeStatistics)
{
statistics.storeParameters();
}
}
catch (Exception ex)
{
Log.Write(this.ToString(), ex);
}
}
public override void Run()
{
Random random = Random();
while (numCats.DecrementAndGet() > 0)
{
string cat = Convert.ToString(random.Next(range));
try
{
tw.AddCategory(new FacetLabel("a", cat));
}
catch (IOException e)
{
throw new Exception(e.Message, e);
}
}
}
public virtual void AddComplete(int rc, LedgerHandle handle, long entryId, object
ctx)
{
lock (this)
{
outstandingRequests.DecrementAndGet();
if (!transmitResult.CompareAndSet(BKException.Code.Ok, rc))
{
Log.Warn("Tried to set transmit result to (" + rc + ") \"" + BKException.GetMessage
(rc) + "\"" + " but is already (" + transmitResult.Get() + ") \"" + BKException.
GetMessage(transmitResult.Get()) + "\"");
}
CountDownLatch l = syncLatch;
if (l != null)
{
l.CountDown();
}
}
}
internal void DecRef()
{
if (@ref.DecrementAndGet() == 0)
{
Exception th = null;
try
{
IOUtils.Close(termVectorsLocal, fieldsReaderLocal, normsLocal, Fields, TermVectorsReaderOrig, FieldsReaderOrig, CfsReader, NormsProducer);
}
catch (Exception throwable)
{
th = throwable;
}
finally
{
NotifyCoreClosedListeners(th);
}
}
}
public override void Run()
{
while (true)
{
IList <T> inputs = null;
try
{
// Wait for notification to start the merge...
lock (pendingToBeMerged)
{
while (pendingToBeMerged.Count <= 0)
{
Sharpen.Runtime.Wait(pendingToBeMerged);
}
// Pickup the inputs to merge.
inputs = pendingToBeMerged.RemoveFirst();
}
// Merge
Merge(inputs);
}
catch (Exception)
{
numPending.Set(0);
return;
}
catch (Exception t)
{
numPending.Set(0);
reporter.ReportException(t);
return;
}
finally
{
lock (this)
{
numPending.DecrementAndGet();
Sharpen.Runtime.NotifyAll(this);
}
}
}
}
/// <summary>
/// Expert: decreases the refCount of this IndexReader
/// instance. If the refCount drops to 0, then this
/// reader is closed. If an exception is hit, the refCount
/// is unchanged.
/// </summary>
/// <exception cref="IOException"> in case an IOException occurs in doClose()
/// </exception>
/// <seealso cref= #incRef </seealso>
public void DecRef()
{
// only check refcount here (don't call ensureOpen()), so we can
// still close the reader if it was made invalid by a child:
if (refCount.Get() <= 0)
{
throw new AlreadyClosedException("this IndexReader is closed");
}
int rc = refCount.DecrementAndGet();
if (rc == 0)
{
Closed = true;
Exception throwable = null;
try
{
DoClose();
}
catch (Exception th)
{
throwable = th;
}
finally
{
try
{
ReportCloseToParentReaders();
}
finally
{
NotifyReaderClosedListeners(throwable);
}
}
}
else if (rc < 0)
{
throw new InvalidOperationException("too many decRef calls: refCount is " + rc + " after decrement");
}
}
protected internal override void DoMerge(MergePolicy.OneMerge merge)
{
try
{
// Stall all incoming merges until we see
// maxMergeCount:
int count = RunningMergeCount.IncrementAndGet();
try
{
Assert.IsTrue(count <= MaxMergeCount, "count=" + count + " vs maxMergeCount=" + MaxMergeCount);
EnoughMergesWaiting.Signal();
// Stall this merge until we see exactly
// maxMergeCount merges waiting
while (true)
{
// wait for 10 milliseconds
if (EnoughMergesWaiting.Wait(new TimeSpan(0, 0, 0, 0, 10)) || Failed.Get())
{
break;
}
}
// Then sleep a bit to give a chance for the bug
// (too many pending merges) to appear:
Thread.Sleep(20);
base.DoMerge(merge);
}
finally
{
RunningMergeCount.DecrementAndGet();
}
}
catch (Exception t)
{
Failed.Set(true);
Writer.MergeFinish(merge);
throw new Exception(t.Message, t);
}
}
public override void Run()
{
try
{
while (Operations.Get() > 0)
{
int oper = rand.Next(100);
if (oper < CommitPercent)
{
if (NumCommitting.IncrementAndGet() <= MaxConcurrentCommits)
{
IDictionary <int, long> newCommittedModel;
long version;
DirectoryReader oldReader;
lock (OuterInstance)
{
newCommittedModel = new Dictionary <int, long>(OuterInstance.Model); // take a snapshot
version = OuterInstance.SnapshotCount++;
oldReader = OuterInstance.Reader;
oldReader.IncRef(); // increment the reference since we will use this for reopening
}
DirectoryReader newReader;
if (rand.Next(100) < SoftCommitPercent)
{
// assertU(h.Commit("softCommit","true"));
if (Random().NextBoolean())
{
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": call writer.getReader");
}
newReader = Writer.GetReader(true);
}
else
{
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": reopen reader=" + oldReader + " version=" + version);
}
newReader = DirectoryReader.OpenIfChanged(oldReader, Writer.w, true);
}
}
else
{
// assertU(commit());
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": commit+reopen reader=" + oldReader + " version=" + version);
}
Writer.Commit();
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": now reopen after commit");
}
newReader = DirectoryReader.OpenIfChanged(oldReader);
}
// Code below assumes newReader comes w/
// extra ref:
if (newReader == null)
{
oldReader.IncRef();
newReader = oldReader;
}
oldReader.DecRef();
lock (OuterInstance)
{
// install the new reader if it's newest (and check the current version since another reader may have already been installed)
//System.out.println(Thread.currentThread().getName() + ": newVersion=" + newReader.getVersion());
Debug.Assert(newReader.RefCount > 0);
Debug.Assert(OuterInstance.Reader.RefCount > 0);
if (newReader.Version > OuterInstance.Reader.Version)
{
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": install new reader=" + newReader);
}
OuterInstance.Reader.DecRef();
OuterInstance.Reader = newReader;
// Silly: forces fieldInfos to be
// loaded so we don't hit IOE on later
// reader.toString
newReader.ToString();
// install this snapshot only if it's newer than the current one
if (version >= OuterInstance.CommittedModelClock)
{
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": install new model version=" + version);
}
OuterInstance.CommittedModel = newCommittedModel;
OuterInstance.CommittedModelClock = version;
}
else
{
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": skip install new model version=" + version);
}
}
}
else
{
// if the same reader, don't decRef.
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": skip install new reader=" + newReader);
}
newReader.DecRef();
}
}
}
NumCommitting.DecrementAndGet();
}
else
{
int id = rand.Next(Ndocs);
object sync = OuterInstance.SyncArr[id];
// set the lastId before we actually change it sometimes to try and
// uncover more race conditions between writing and reading
bool before = Random().NextBoolean();
if (before)
{
OuterInstance.LastId = id;
}
// We can't concurrently update the same document and retain our invariants of increasing values
// since we can't guarantee what order the updates will be executed.
lock (sync)
{
long val = OuterInstance.Model[id];
long nextVal = Math.Abs(val) + 1;
if (oper < CommitPercent + DeletePercent)
{
// assertU("<delete><id>" + id + "</id></delete>");
// add tombstone first
if (Tombstones)
{
Document d = new Document();
d.Add(OuterInstance.NewStringField("id", "-" + Convert.ToString(id), Documents.Field.Store.YES));
d.Add(OuterInstance.NewField(OuterInstance.Field, Convert.ToString(nextVal), StoredOnlyType));
Writer.UpdateDocument(new Term("id", "-" + Convert.ToString(id)), d);
}
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": term delDocs id:" + id + " nextVal=" + nextVal);
}
Writer.DeleteDocuments(new Term("id", Convert.ToString(id)));
OuterInstance.Model[id] = -nextVal;
}
else if (oper < CommitPercent + DeletePercent + DeleteByQueryPercent)
{
//assertU("<delete><query>id:" + id + "</query></delete>");
// add tombstone first
if (Tombstones)
{
Document d = new Document();
d.Add(OuterInstance.NewStringField("id", "-" + Convert.ToString(id), Documents.Field.Store.YES));
d.Add(OuterInstance.NewField(OuterInstance.Field, Convert.ToString(nextVal), StoredOnlyType));
Writer.UpdateDocument(new Term("id", "-" + Convert.ToString(id)), d);
}
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": query delDocs id:" + id + " nextVal=" + nextVal);
}
Writer.DeleteDocuments(new TermQuery(new Term("id", Convert.ToString(id))));
OuterInstance.Model[id] = -nextVal;
}
else
{
// assertU(adoc("id",Integer.toString(id), field, Long.toString(nextVal)));
Document d = new Document();
d.Add(OuterInstance.NewStringField("id", Convert.ToString(id), Documents.Field.Store.YES));
d.Add(OuterInstance.NewField(OuterInstance.Field, Convert.ToString(nextVal), StoredOnlyType));
if (VERBOSE)
{
Console.WriteLine("TEST: " + Thread.CurrentThread.Name + ": u id:" + id + " val=" + nextVal);
}
Writer.UpdateDocument(new Term("id", Convert.ToString(id)), d);
if (Tombstones)
{
// remove tombstone after new addition (this should be optional?)
Writer.DeleteDocuments(new Term("id", "-" + Convert.ToString(id)));
}
OuterInstance.Model[id] = nextVal;
}
}
if (!before)
{
OuterInstance.LastId = id;
}
}
}
}
catch (Exception e)
{
Console.WriteLine(Thread.CurrentThread.Name + ": FAILED: unexpected exception");
Console.WriteLine(e.StackTrace);
throw new Exception(e.Message, e);
}
}
public virtual void DecRef()
{
int rc = RefCount_Renamed.DecrementAndGet();
Debug.Assert(rc >= 0);
}
public Address WithHighId(string name) => new Address(highId.DecrementAndGet(), name);
public void DecrementConcurrentExecutionCount()
{
concurrentExecutionCount.DecrementAndGet();
}
private void Increment()
{
_consumeCount.IncrementAndGet();
_remaining.DecrementAndGet();
}
public void DecreaseRequestCount(string requestIdentity)
{
AtomicInteger counter = RequestCounters.GetOrAdd(requestIdentity, id => new AtomicInteger());
counter.DecrementAndGet();
}
public void OnClose(IndexReader reader)
{
Count.DecrementAndGet();
}
/// <exception cref="System.IO.IOException"/>
public override void ReleaseFileSystem(FileSystem fs)
{
unmanagedFileSystems.DecrementAndGet();
CloseFileSystem(fs);
}
/// <summary>
/// 服务并发量自减
/// </summary>
internal void DecrementConcurrentExecutionCount()
{
serviceConcurrentExecutionCount.DecrementAndGet();
}
/// <summary>decrements and returns pending predecessor task count</summary>
public virtual int DecrementAndGetPendingPredecessorTasks()
{
return(numberOfPendingPredecessorTasks.DecrementAndGet());
}
internal static int DecrementGlobalConcurrentThreads()
{
return(_concurrentThreadsExecuting.DecrementAndGet());
}
public void MarkThreadCompletion()
{
_concurrentExecutionCount.DecrementAndGet();
}