ロック
ReentrantLockの
フラグを渡す建設時RLOCKは権威が最長のスレッドを待たせる傾向があるかどうかのリリースでは、そうでない場合は、ロックを取得するために保証順序を行いませんと、ロックを示す、ブール公平です。ロックフェアは、飢餓のリスクなしに、パフォーマンスの大幅な損失が、より小さい取得ロック時間分散のメリットをもたらすでしょう。
コールのtryLock RLOCK（）メソッドは、とき公正マーク、長い何のスレッドがロックを保持していない限り、この時間は、あなたがロックに入ることができるかどうか、気にしないそれらのスレッドがロックを待っている気にしないでください。ない場合はロックを取得するには、この時点で、Lockクラスから継承されたのtryLock（）は、それが実行中のスレッドをブロックせずに、直接、falseを返します。
RLOCK内部クラスを継承同期AQSクラス、このクラスを通じてセマンティックロック。スレッドの数が同期状態のメンバーとロック（リエントラント）を保持する場合を示します。Syncは、公正なサブクラスは2つのバージョンが、デフォルト以外のフェアが含まれているかどうか。
応答が中断ロックを待っている間、スレッドがブロックされていることをRLOCKロックの違い（）とlockInterruptibly（）。別のスレッドがロックを獲得するために、このスレッドを取得するには、このスレッドに割り込んだ場合、lockInterruptibly（）の呼び出し側は、スレッドがブロックし停止します。
sync.nonfairTryAcquireのtryLock（）メソッド（1）を達成するために呼び出すことで。この方法は、存在する場合、他のスレッドが直接変更する、任意の直接返し偽、そうでない場合は状態= 0（ロックを保持しないスレッド）または現在== getExclusiveOwnerThread（）（このスレッドが保持されている）、ロックを保持しているかを決定するだけであるので状態ステータス、そして真に戻ります。コードは以下の通りであります：
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
复制代码ここでは主にロック方法の実現を確認してください。ロック（sync.lockを呼び出すことによって（）メソッド）。状況フェアを見てください。（R）錠（） - >（R）sync.lock（） - >（A）を取得（1） - >（A）
public final void acquire(int arg) {
//如果tryAcquire成功，后面自然不用执行，否则排队（所以线程在队列中只会有一个节点）
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
复制代码私たちは、acquireQueuedスレッドがブロッキング状態に入ると思います。ステップバイステップでまず見て、最初のステップはaddWaiterです。
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
复制代码注意を払うことに加えて、リスト、深さに他の一見何の終わりに道CAS詰めノードを使用して、スキップします。このステップの終了後、私たちは、このスレッドは何それから、キューの末尾にノードの代表を正常に作成していますか？
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
复制代码取得方法では、我々はtryAcquire一度（）メソッドを見てきました、我々はそれが事態のために虚偽だったと仮定して、戻っていき、今の顔、その実装を見て必要であると考えられます。驚くべきことに、tryAcquire（）メソッドは、私たちが自分自身を実現するために必要な、抽象AQSの内部にあります。tryLock（）から出発し、我々はnonfairTryAcquire（）メソッドを見てきましたが、この方法の観点から、関係なく、それを達成するためにどのようにロックを獲得するために、公正、成功真、失敗、偽、その後、tryAcquire（）であるかどうかの名前ですか？
tryAcquireはNonfairSync下で達成しました
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
复制代码tryAcquireはFairSync下で達成しました
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//这儿就是判断是否fair的关键代码，先判断是是否在排队呢
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
复制代码ロック（）メソッドは、次のtryAcquire同期クラスのメソッドになってきたが、これを達成するために、異なるサブクラスSyncメソッドを見ることができますが同じではありません。つまり、acquireQueuedがそれに近づく戻っていました
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//是这里让线程阻塞了
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
//可以直接把interruptedException抛出来，这就是lockInterupt()方法的做法
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
复制代码この方法を見てください
/**
* Checks and updates status for a node that failed to acquire.
* Returns true if thread should block. This is the main signal
* control in all acquire loops. Requires that pred == node.prev.
*
* @param pred node's predecessor holding status
* @param node the node
* @return {@code true} if thread should block
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
复制代码この方法の目的は、主に2つです
- 、ノードに知らせる必要が私を知らせるためにと、ロックを解除する（プロセッサのステータスが新葛に設定されています）
- スレッドのノードはキャンセルキャンセル占有します
上記なさ準備作業は、このスレッドは易さ「休息」で感じることができます。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
//注意，这里检测了线程是否被interrupted。如果此时捕获到中断的信息，需要在上面代码中“抛出”此中断，让其他实现中断响应策略的代码，能够获知这一状态。
return Thread.interrupted();
}
复制代码今、ブロックされたスレッドの中へと見なさ。目覚めたときは？UNLOCK（）のコードを見て：
public void unlock() {
sync.release(1);
}
复制代码コードリンクである（R）ロック解除（） - >（A）放出（） - >（R）tryRelease（）
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
复制代码この操作は、実質的に反対tryAcquireです。リリースが成功した場合は、キューのスレッドが最初のノード、コードをリリース置きます：
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
复制代码同期
何がはい同期？
たCountDownLatch
スレッドのCDLは、以上の一連の動作を完了するために、別のスレッドを待機します。初期化時にカウントを減少させるために各動作が完了し、コールカウントダウンを（）のカウントを指定します。全てのawaitでブロックされたときに0にカウントを減少させる場合（）スレッド上記の方法は、すぐに実行されます。注カウントはリセットしたい場合は、CyclicBarrierをを使用することが推奨され、リセットできません。
CDLは、メモリの整合性の原則を確保することができます：スレッドがカウントダウン（）メソッドは、メソッドが戻る前に、他のスレッドのawaitでアクションの前に発生していなければなりません（）を呼び出します。
CDLはまた、内部AQSのカテゴリー、すなわち同期クラスを継承し、好きなRLOCKを達成。acquireSharedInterruptibly>（A） - （C）のawait（）：CDL（）は、プロセス分析を待ちます
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
复制代码そして、RLOCKは同様に、それを得るための最初の試みはtryAcquireSharedとロック
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
复制代码CDLを初期化すると、入ってくる状態が数カウント指定されているので、それ以外の場合は、AQSと呼ばれる、この方法はゼロに減少した場合にゼロに減少状態は、実行ダウンをブロックしていないかどうかを調べることですtryAcquireShared doAcquireSharedInterruptibly方法：
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
复制代码私たちは、上記の基本的に類似し、この方法とacquireQueued方法を見つけました
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//是这里让线程阻塞了
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
//可以直接把interruptedException抛出来，这就是lockInterupt()方法的做法
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
复制代码違いは、このノードの前駆体はヘッドノードである場合、コールはそれ以上tryAcquire共有ものよりも、方法をtryAcquireSharedれる（彼は最初の行が今であることを意味する）ことです。tryAcquireの方法は一般に比較的単純で達成し、実際の平均tryAcquireほとんど、これは、共有に設定されているノードのステータスの他の部分に加えて、この状態では少し複雑であり、それは違いはありません上に、同じロジックをブロッキングしました。
そして、見た目のカウントダウン（）メソッド。
public void countDown() {
sync.releaseShared(1);
}
复制代码そして、AQSに入ります
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
复制代码あなたが0にtrueを返すまでCDLが、状態は1になり、スレッドは、この時期にリリースされます
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
复制代码private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
复制代码セマフォ
Sは、いくつかの内部のライセンスのために、スレッドは、ライセンスが割り当てられたときにまで、ライセンスを取得していないブロックされています。リリースライセンスライセンスはSに増加したときに、それゆえ、Sは通常、リソースにアクセスするスレッドの数を制御するために使用されます。Sは、バイナリセマフォで初期化時にのみ1ライセンス、異なる役割を持っており、それをロックし、このスレッドの解放を自分でロックをロックする必要があるため、およびBSは、この要件を持つことができません。
セマフォもそれはRLOCKは同じ意味、公正であるかどうかを分けます。
セマフォまた、AQS Snyc.Sync（状態）のサブクラスの初期内部状態が許可の数で実現する利用可能な許可の数を表します。Sルックの取得方法の：
//注意，semaphore的acquire默认是可以中断的，如果要不中断可以调用acquireUninterruptibly()
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
复制代码public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
复制代码RLOCKのルックスは、それ以外の場合は、最高の成功した場合、取得がときに最初、それを試して、好き
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
复制代码そして、CDLこのように、すべてのノードがモードを共有しました。
同時コンポーネントをカスタマイズするためには、上記の例からわかるように、あなたはいくつかのことを行う必要があります
- キューを提供するために使用される内部連続AQSクラス、ブロッキング機能
- あなたがしよう（状態）によって同時部品、最初の試みを同期する必要がある場合は、それがロックを取得することはできません、すべてが正常にテストされます成功すると、スレッドが続行されます。あなたがしようと成功しない場合はその実行をブロックしながら、AQSすることにより、このスレッドは、キューに追加します。
- あなたは、ロックを解除するために国家の最初tryRelease AQSと、このような再入国の数を減らすなど、他の情報の変更、（例えば、0 RLOCK、0まででCDLなど）私たちが望む結果への変更をしたい場合は同時コンポーネントは、それがAQSによるであろうノード解放、ブロック解除のスレッド間。
ほとんどのカスタム・ロジックは、我々はそれが我々がgetStateを0にする必要がある場合、同様に？などgetStateを0ではない偽を返したときにしようとするために必要なものであること、我々はスレッド（挿入ノード）をブロックする必要がある場合ということですか？
どのように我々は、同期ツールを達成するためにありますか？
public class MyThreadSyncUtil {
private Sync sync;
class Sync extends AQS {
booleean tryAcquire();
}
//会阻塞，还可以区分是否响应中断，区别在于调用sync中响应中断的acquire，区别是此时park完线程以后判断是否抛出intrupted异常
public void acquire() {
sync.acquire(); // -> 这里面会用到我们刚刚实现的try，try成功就返回，否则将节点加入到队列
}
//直接返回
public boolean tryAcquire(){
sync.tryAcquire();
}
}
复制代码CyclicBarrierを
タスクの完了後も継続するタスクの後ろにお互いに待機しているスレッドのシリーズを使用してCBシーン。それは、スレッドの以降のリリースで再利用可能な巡回手段。Runnableを渡すCBのサポートは、すべてのスレッドがそれを実行するために（まだリリースされていないが、）タスクを完了するために時を示します。
それらのタスクを実行する各スレッドの完了後、cyclicBarrier.await（）メソッドを呼び出し、完全にすべてのタスクをブロックします。awaitコード：
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
复制代码主にコードdowait：
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
final ReentrantLock lock = this.lock;
lock.lock();
try {
final Generation g = generation;
//如果barrier被破坏，直接抛出异常结束
if (g.broken)
throw new BrokenBarrierException();
//如果这个线程中途被中断，会中断barrier
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
int index = --count;
//最后一个执行的线程需要执行以下barrierCommand
if (index == 0) { // tripped
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
// loop until tripped, broken, interrupted, or timed out
for (;;) {
try {
if (!timed)
//一般情况下会阻塞在这里
trip.await();
else if (nanos > 0L)
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
//阻塞的时候如果被中断，先结束barrier再抛出异常
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
// We're about to finish waiting even if we had not
// been interrupted, so this interrupt is deemed to
// "belong" to subsequent execution.
Thread.currentThread().interrupt();
}
}
//有可能中途被唤醒（因为broken），判断出错以后抛出异常
if (g.broken)
throw new BrokenBarrierException();
//有可能更新到下一代
if (g != generation)
return index;
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();
}
}
复制代码breakBarrierコードがあります
private void breakBarrier() {
//broken这个状态属于generation
generation.broken = true;
count = parties;
trip.signalAll();
}
复制代码