Verwandte kostenlose Lernempfehlungen: Java-Grundlagen-Tutorial
Häufig verwendete Hilfsklassen
public class CountDownLatchDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i{
System.out.println(Thread.currentThread().getName()+"\t离开教室");
},String.valueOf(i)).start();
}
System.out.println(Thread.currentThread().getName()+"\t班长关门走人");
}}Schließlich sind drei Personen im Lehrerzimmer eingesperrt. Dies kann zu Unfällen führen, ist also definitiv nicht möglich.
Wenn wir diesen Effekt erzielen möchten, müssen wir warten, bis alle anderen Threads ausgeführt wurden, bevor der Hauptthread ausgeführt werden kann. Sie müssen die CountDownLatch-Klasse in JUC verwenden
1.2. Einführung in die CountDownLatch-Klasse:
1.2.1 CountDownLatch-Konzept 
CountDownLatch ist eine Synchronisierungstoolklasse, die zur Koordinierung der Synchronisierung zwischen mehreren Threads oder auf andere Weise verwendet wird Wörter dienen der Kommunikation zwischen Threads (und nicht als gegenseitiger Ausschluss).
CountDownLatch ermöglicht es einem Thread, darauf zu warten, dass andere Threads ihre Arbeit abschließen, bevor er mit der Ausführung fortfährt
.Verwenden Sie zur Umsetzung einen Zähler. Der Anfangswert des Zählers ist die Anzahl der Threads. Wenn jeder Thread seine Aufgabe abschließt, wird der Zählerwert um eins verringert. Wenn der Zählerwert 0 ist, bedeutet dies, dass alle Threads einige Aufgaben abgeschlossen haben und die auf CountDownLatch wartenden Threads dann mit der Ausführung der nächsten Aufgaben fortfahren können.
CountDownLatch-Beschreibung: Anzahl zählen, herunterzählen, Latch starten1.2.3 Verwendung von CountDownLatch
Ein bestimmter Thread wartet, bis die Ausführung von n Threads abgeschlossen ist, bevor er mit der Ausführung beginnt. Initialisieren Sie den CountDownLatch-Zähler auf den neuen CountDownLatch(n). Immer wenn ein Task-Thread die Ausführung abschließt, wird der Zähler um 1 verringert. countdownLatch.countDown() Wenn der Zählerwert 0 wird, wird der Thread waiting() auf CountDownLatch aktiviert. Ein typisches Anwendungsszenario besteht darin, dass der Hauptthread beim Starten eines Dienstes warten muss, bis mehrere Komponenten geladen sind, bevor er mit der Ausführung fortfahren kann. CountDownLatch zugrunde liegender Konstruktor-Quellcode
public CountDownLatch(int count) {
if (count <p></p>1.3. CountDownLatch-Fall: <p><strong><pre class="brush:php;toolbar:false">public static void main(String[] args) throws InterruptedException {
//6个同学正在上自习，每个人就有一个1计数器，走1个数字减1，main线程启动，必须要等计时器从6变成0，才能开始。
CountDownLatch countDownLatch=new CountDownLatch(6);
for(int i=1;i{
System.out.println(Thread.currentThread().getName()+"\t离开教室");
countDownLatch.countDown(); //计算减少一个
},String.valueOf(i)).start();
}
countDownLatch.await(); //班长前面需要被阻塞
System.out.println(Thread.currentThread().getName()+"\t班长关门走人");
} Ich weiß nicht, wann alle hier gehen werden, aber Sie können garantieren, dass der Truppführer der letzte sein wird Einer, der jedes Mal gehen muss.
CountDownLatch verfügt hauptsächlich über zwei Methoden. Wenn ein oder mehrere Threads die Wait-Methode aufrufen, werden diese Threads blockiert.
Der Aufruf der CountDown-Methode durch andere Threads verringert den Zähler um 1 (der Thread, der die CountDown-Methode aufruft, wird nicht blockiert).
Wenn der Zählerwert 0 wird, wird der von der Wait-Methode blockierte Thread aktiviert und die Ausführung wird fortgesetzt. 
2.CyclicBarrier
2.1. Einführung in CyclicBarrier
zyklischer Zyklus, Barrierebarriere. Aus der wörtlichen Bedeutung können wir erkennen, dass die chinesische Bedeutung dieser Klasse „umlaufender Zaun“ ist. Es bedeutet in etwa eine recycelbare Barriere.
Seine Funktion besteht darin, alle Threads auf den Abschluss warten zu lassen, bevor mit dem nächsten Schritt fortgefahren wird. Das obige Beispiel, in dem der Monitor die Tür schließt, dient dazu, einen Countdown durchzuführen, hier ist es umgekehrt, eine Addition durchzuführen und zu starten, wenn die Zahl erreicht ist.
Wenn zum Beispiel alle da sind, starten Sie das Meeting erneut. Wie im Leben würden wir beispielsweise Kollegen bitten, gemeinsam zu einem Meeting zu gehen. Einige Kollegen kommen möglicherweise früher und einige Kollegen kommen möglicherweise zu spät. Bei diesem Meeting müssen wir jedoch warten, bis alle angekommen sind das Treffen offiziell eröffnen. Die Kollegen hier sind die Threads und das Treffen ist die CyclicBarrier.
Konstruktionsmethodepublic CyclicBarrier(int parties)public CyclicBarrier(int parties, Runnable barrierAction)
2.2. Fall: Sammle 7 Drachenbälle, um den Drachen zu beschwören
public static void main(String[] args) {
// TODO Auto-generated method stub
CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{System.out.println("召唤神龙");});
for(int i=1;i{
System.out.println(Thread.currentThread().getName()+"\t收集到第"+tempInt+"颗龙珠");
try {
//某个线程收集到了龙珠只能先等着，等龙珠收齐了才能召唤神龙
cyclicBarrier.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
},String.valueOf(i)).start();;
}
}截图
3.Semophore
3.1.Semophore简介
前面讨论的问题都是多对一的问题，我们现在可以讨论多对多的问题了。
假设有7个兄弟开车上班，而现在只有4个车位。7部车并列开进4个车位，每个车停了多长时间未知，资源被占用完了。假设有一个车只停了2s,那么它走了，外面的车又可以进来了。走一个进一个，最后全部都可以进去。而semophore就是控制多线程的并发策略。
简单理解来说，Semaphore：信号量主要用于两个目的：一个是用于多个共享资源的互斥使用；另一个用于并发线程数量的控制。
Semaphore类有两个重要方法
1、semaphore.acquire();
请求一个信号量，这时候信号量个数-1，当减少到0的时候，下一次acquire不会再执行，只有当执行一个release()的时候，信号量不为0的时候才可以继续执行acquire
2、semaphore.release();
释放一个信号量，这时候信号量个数+1，
3.2.抢车位问题
public static void main(String[] args) {
//模拟6部车抢3个空车位
Semaphore semaphore=new Semaphore(3);//模拟资源类，有3个空车位
for(int i=1;i{
try {
//谁先抢到了，谁就占一个车位，并且要把semaphore中的资源数减1
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"\t抢占到了车位");
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"\t离开了车位");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//释放车位
semaphore.release();
}
},String.valueOf(i)).start();
}
}运行结果截图：
3.3.原理总结
在信号量上我们定义两种操作：
acquire(获取)当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等待下去，直到有线程释放信号量，或超时。
release(释放)实际上会将信号量的值加1，然后唤醒等待的线程。
信号量主要用于两个目的：一个是用于多个共享资源的互斥使用；另一个用于并发线程数量的控制
如果把资源数从3变成1了，此时就等价于synchronized。
Das obige ist der detaillierte Inhalt vonParallele Java-Programmierung, Einführung häufig verwendeter Hilfsklassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Einführung in Festplattenschnittstellentypen
Was ist Bitcoin? Ist es ein Betrug?
So runden Sie in Matlab
Was soll ich tun, wenn das übereinstimmende Ergebnis der Vlookup-Funktion N/A lautet?
Der Computer meldet, dass msvcr110.dll fehlt und wie man das Problem beheben kann
Wie viel entspricht Snapdragon 8gen2 Apple?
Was ist j2ee
So deaktivieren Sie die ICS-Netzwerkfreigabe
