4.javaマルチスレッドインターリーブプリントAとB？
3. Javaはスレッドの同期のよりエレガントな実装マルチスレッド交互印刷Aを、B LockSupportを達成します
交互問題を印刷する二つのスレッドを達成2.Java
1. A、B 2つのスレッドが交互1--100印刷されています
====
4.javaマルチスレッドインターリーブプリントAとB？
キーは、印刷方法Aであり、そしてB、同期オブジェクトが1つに保持されている同じ、すなわちロックと同様、このクラスのすべての印刷インスタンスであり
、次いで、符号ではなく、自分の時間、彼らはロックを解除、及びてみましょうスレッドは待機状態がthis.waitは（）である入っ
実装した後、彼のターン、印刷可能な文字を説明しながら、フラグを設定する場合は、このスレッドにロックを覚まします。
印刷{クラス
trueにブール=ノワ;
同期無効Printa（）{
しばらく（ノワ！）{
試み{
this.wait（）;
}キャッチ（例外E）{
}
}
ノワ= falseに;
System.out.printlnは（にThread.currentThread （）+ "" + "A"）;
this.notify（）;
}
同期ボイドprintB（）{
一方（ノワ）{
試み{
this.wait（）;
}キャッチ（例外E）{
}
}
ノワ= TRUE。
System.out.println（にThread.currentThread（）+ " "+" B"）。
this.notify（）;
}
}
publicクラスTest3は{
公共の静的な無効メイン（文字列[] args）{
プリントプリント=新しいプリント（）。
新しいスレッド（新しいRunnableを（）{
@Override
公共ボイドラン（）{
; I <10; I ++）{（INTはI = 0ため
print.printA（）;
}
}
}）。）（開始。
新しいスレッド（新しいRunnableを（）{
@Override
ます。public void実行（）{
のためには、（int型iは= 0;私<10; iが++）{
print.printB（）;
}
}
}）。）（開始;;
}
}
3. Javaはスレッドの同期のよりエレガントな実装マルチスレッド交互印刷Aを、B LockSupportを達成します
問題の概要
スレッドやプロセスの同期と相互排他の関係の二種類があり、我々は通常、同期方法を達成するためには、待機中のスレッドがウェイクアップ機構を、ウェイクアップ機構を待っては継承の独占的な使用に基づいている間に使用することです。
しかし、同時スレッドは、必ずしも相互に排他的で達成することはありませ。例えば、Aを印刷するスレッド、印刷スレッドB. これら二つのスレッドそのような需要がない排他的な関係はありませんが、製：代替印刷Aは、B.
私たちの一般的な解決策は、（）/メカニズムを通知待機を使用することがしばしばあります。
二LockSupportが紹介
ユーティリティクラス、その主な学習方法としてLockSupportを。
公園（）：スレッドで呼び出し、ライセンスまで自己表現のブロックの現在のスレッド
公園（スレッド変数）：ライセンスを取得するために指定したスレッドをしてみましょう。
これらの2つの方法の定義を見て、これらの2つの方法の使用は、実装コール（同期）シーケンスのスレッドは明らかであろう
A / Bの印刷を実現する32個の代替アイデアの種類
ウェイクアップメカニズムを待っている：
/ **
* @program：テスト
* @description：ウェイクアップ機構を待って交流A / Bを印刷
* @author：
* @Create：2019年7月22日夜02時28
* /
publicクラスTest3は{
静的クラスMyRun実装Runnableを{
静的INT I = 0。
@Override
パブリック（）はボイド実行を同期{
ため（INT J = 0であり、j <10; J ++）{
IF（I％2 == 0）
のSystem.out.println（にThread.currentThread（）のgetName（）+ "： A "）;
他
のSystem.out.println（にThread.currentThread（）のgetName（）+ "：B"）;
I ++;
this.notifyAll（）;
試す{
IF（I> = 19）
のThread.sleep（10）。
他
this.wait（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
}
}
}
パブリック静的無効メイン（文字列[] args）{
MyRun myRun =新しいMyRun（）。
=新しいスレッド（myRunを）スレッド。
スレッドB =新しいスレッド（myRun）。
a.start（）;
b.start（）;
}
}
java.util.concurrent.locks.LockSupport实现
/ **
* @program：テスト
* @description：交替打印A、B LockSupport实现
* @author：
* @Create：2019年7月22日夜02時03分
* /
公共クラスTest2を{
静的スレッドA = NULL;
静的スレッドB = NULL;
パブリック静的無効メイン（文字列[] args）{
=新しいスレッド（新しいRunnableを（）{
@Override
公共ボイドラン（）{
（INTのためにI = 0、I <10; iは++）{
LockSupport.park（）;
システム.out.println（にThread.currentThread（）のgetName（）+ "B"）;
LockSupport.unpark（B）;
}
}
}）。
B =新しいスレッド（（新しいRunnableを（）{
@Override
ます。public void実行（）{
（int型のために、私は= 0; I <10; I ++）{
System.out.println（にThread.currentThread（）のgetName（）+ "：A"）;
LockSupport.unpark（A）。
LockSupport.park（）;
}
}
}））。
a.start（）;
b.start（）;
}
}
2.Java交互問題印刷二つのスレッド
、スレッド1がA、B、Cを印刷するための責任がある、D
スレッドは2、3、4を印刷するための責任があり、コンテンツは、コンソール出力がa1b2c3d4ある必要
パブリッククラスいるTestMain {
静的最終的なオブジェクトのオブジェクト=新しいオブジェクト（）;
公共の静的な無効メイン（文字列[]引数）はInterruptedExceptionある{スロー
新しいスレッド（新しいRunnableを（）{
;列[] = { ""、 "B"、 "C"、 "D"}
@Override
公共ボイドラン（ ）{
I <4; I ++）{（INTはI = 0のための
同期（オブジェクト）{
するSystem.out.println（ "线程A开始执行"）;
object.notify（）;
試み{
System.out.printlnは（」线程A开始等待"）;
はObject.wait（）。
e.printStackTrace（）;
}
のSystem.out.println（ "スレッドを継続する"）;
のSystem.out.println（[I]）;
のSystem.out.println（ "スレッドの実行が終了"）;
Object.notify （）;
}
}
}
}）を起動します。（）;
新しい新しいスレッド（Runnableを新しい新しい（）{
int型A [] = {1,2,3,4};
@Override
公共ボイドRUN（）{
用（INT I = 0 ; I <4; I ++）{
同期（オブジェクト）{
するSystem.out.println（ "スレッドの実行を1つの開始"）。
Object.notify（）;
試み{
するSystem.out.println（ "スレッド1を待機開始"）
はObject.wait（）;
}キャッチ（InterruptedExceptionあるE）{
e.printStackTrace（）;
}
のSystem.out.println（「スレッド";）継続する1
;のSystem.out.println（A [I]）
）」1つの実行終了スレッド;のSystem.out.println（"
}
}
}
}）を起動（）;
}
}
オプション1：
パブリッククラスTest100_02 {
プライベート静的オブジェクトのオブジェクト=新しいオブジェクト（）;
プライベート静的ブールisFlag =偽;
パブリック静的無効メイン（文字列[] args）{
スレッドT1は=新しいスレッド（（） - > {
ためには、（INT iは1 =; I <= 999; I + = 2）{
同期（オブジェクト）{
IF（isFlag）{！
System.out.println（ "現在：" + i）を、
isFlag = TRUE;
試み{
はObject.wait（）;
}キャッチ（InterruptedExceptionあるE）{
e.printStackTrace（）;
}
object.notify（）;
}
}
}
}）。
スレッドT2 =新しいスレッド（（） - > {
（INTのためにI = 2、I <= 1000; I + = 2）{
同期（オブジェクト）{
IF（isFlag）{
isFlag = FALSE;
のSystem.out.println（「現在：」+ I）;
object.notify（）;
試み{
はObject.wait（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
}
}
}
}）。
t1.setPriority（Thread.MAX_PRIORITY）。
t1.start（）;
t2.start（）;
}
}
方案二：
輸入java.util.concurrent.locks.Condition。
輸入java.util.concurrent.locks.Lock;
輸入java.util.concurrent.locks.ReentrantLock;
パブリッククラスTest100_01 {
プライベート静的ロックロック=新しいReentrantLockの（）;
プライベート静的条件条件1 = lock.newCondition（）;
プライベート静的条件条件2 = lock.newCondition（）;
パブリック静的無効メイン（文字列[] args）{
//スレッド1
スレッドT1 =新しいスレッド（（） - > {
INT（iについては、= 1; I <= 999; I + = 2）{
lock.lock（）。
してみてください{
System.out.printlnは（ "現在：" + I）;
condition1.await（）;
condition2.signal（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
lock.unlock（）。
}
}）。
//スレッド2
スレッドT2 =新しいスレッド（（） - > {
（int型のために、私は= 2; I <= 1000; I + = 2）{
lock.lock（）;
試み{
System.out.printlnは（ "現在： 「+ I）;
condition1.signal（）;
condition2.await（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
lock.unlock（）;
}
}）;
t1.setPriority（Thread.MAX_PRIORITY）;
t1.start（）;
t2.start（）;
}
}
あなたのコードのルックス私は途中で立ち往生ランニングになりますように、
私は、ビットシーケンスを改善しました
condition2.signal（）;
System.out.println（ "現在：" + I）。
condition1.await（）;
condition1.signal（）;
System.out.println（ "現在：" + I）。
condition2.await（）;
オプション1：
パブリッククラスTest100_02 {
プライベート静的オブジェクトのオブジェクト=新しいオブジェクト（）;
プライベート静的ブールisFlag =偽;
パブリック静的無効メイン（文字列[] args）{
スレッドT1は=新しいスレッド（（） - > {
ためには、（INT iは1 =; I <= 999; I + = 2）{
同期（オブジェクト）{
IF（isFlag）{！
System.out.println（ "現在：" + i）を、
isFlag = TRUE;
試み{
はObject.wait（）;
}キャッチ（InterruptedExceptionあるE）{
e.printStackTrace（）;
}
object.notify（）;
}
}
}
}）。
スレッドT2 =新しいスレッド（（） - > {
（INTのためにI = 2、I <= 1000; I + = 2）{
同期（オブジェクト）{
IF（isFlag）{
isFlag = FALSE;
のSystem.out.println（「現在：」+ I）;
object.notify（）;
試み{
はObject.wait（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
}
}
}
}）。
t1.setPriority（Thread.MAX_PRIORITY）。
t1.start（）;
t2.start（）;
}
}
方案二：
輸入java.util.concurrent.locks.Condition。
輸入java.util.concurrent.locks.Lock;
輸入java.util.concurrent.locks.ReentrantLock;
パブリッククラスTest100_01 {
プライベート静的ロックロック=新しいReentrantLockの（）;
プライベート静的条件条件1 = lock.newCondition（）;
プライベート静的条件条件2 = lock.newCondition（）;
パブリック静的無効メイン（文字列[] args）{
//スレッド1
スレッドT1 =新しいスレッド（（） - > {
INT（iについては、= 1; I <= 999; I + = 2）{
lock.lock（）。
してみてください{
System.out.printlnは（ "現在：" + I）;
condition1.await（）;
condition2.signal（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
lock.unlock（）。
}
}）。
//スレッド2
スレッドT2 =新しいスレッド（（） - > {
（int型のために、私は= 2; I <= 1000; I + = 2）{
lock.lock（）;
試み{
System.out.printlnは（ "現在： 「+ I）;
condition1.signal（）;
condition2.await（）;
}キャッチ（InterruptedExceptionある電子）{
e.printStackTrace（）;
}
lock.unlock（）;
}
}）;
t1.setPriority（Thread.MAX_PRIORITY）;
t1.start（）;
t2.start（）;
}
}
あなたのコードのルックス私は途中で立ち往生ランニングになりますように、
私は、ビットシーケンスを改善しました
condition2.signal（）;
System.out.println（ "現在：" + I）。
condition1.await（）;
condition1.signal（）;
System.out.println（ "現在：" + I）。
condition2.await（）;