Dans une récente interview, j'ai rencontré une question sur les trois classes d'outils de synchronisation des threads Java. Je ne m'en souvenais pas avant de l'avoir examinée. Lorsque j'apprenais le multithread, je n'ai pas étudié la classe d'outils de synchronisation. soigneusement, et maintenant je l'ai même oublié. Par conséquent, je l'ai revu et je l'ai trouvé assez profond, je l'ai donc compilé et écrit un article pour votre référence. apache php mysql
Java nous fournit trois classes d'outils de synchronisation :
CountDownLatch (lock) :
Un fil attend pour que les autres threads terminent leur exécution avant de s'exécuter (les autres threads attendent qu'un thread termine son exécution avant de s'exécuter)
CyclicBarrier (barrière) :
A un groupe de threads s'attendent les uns les autres pour atteindre un certain état, puis le groupe de threads s'exécute en même temps.
Sémaphore :
Contrôlez un groupe de threads à exécuter simultanément.
Pour parler franchement, ces classes d'outils sont conçues pour mieux contrôler les problèmes de communication entre les threads~
En termes simples : CountDownLatch est une classe auxiliaire synchronisée qui
- Une aide à la synchronisation qui permet à un ou plusieurs threads d'attendre la fin d'un ensemble d'opérations effectuées dans d'autres threads.
permet à un ou plusieurs threads d'attendre jusqu'à ce que d'autres threadsterminentleurs opérations . Il existe en fait deux API couramment utilisées :
etawait()countDown()
Instructions d'utilisation :
Lorsque le nombre diminue à 0, tous les threads en attente seront libéréscountDown()
. la valeur du compte est 0 (les tâches des autres threads sont terminées), alors l'exécution peut continuer.
import java.util.concurrent.CountDownLatch;
public class Test {
public static void main(String[] args) {
final CountDownLatch countDownLatch = new CountDownLatch(5);
System.out.println("现在6点下班了.....");
// 3y线程启动
new Thread(new Runnable() {
@Override
public void run() {
try {
// 这里调用的是await()不是wait()
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("...其他的5个员工走光了，3y终于可以走了");
}
}).start();
// 其他员工线程启动
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("员工xxxx下班了");
countDownLatch.countDown();
}
}).start();
}
}
}
Écrivez un autre exemple : 3y est désormais responsable de la fonction du module d'entrepôt, mais sa capacité est trop faible et il écrit très lentement.
Résultat de sortie :
import java.util.concurrent.CountDownLatch;
public class Test {
public static void main(String[] args) {
final CountDownLatch countDownLatch = new CountDownLatch(1);
// 3y线程启动
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3y终于写完了");
countDownLatch.countDown();
}
}).start();
// 其他员工线程启动
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("其他员工需要等待3y");
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3y终于写完了，其他员工可以开始了！");
}
}).start();
}
}
}
2. CyclicBarrier
Mode d'emploi :Une aide à la synchronisation qui permet à un ensemble de threads de s'attendre les uns les autres pour atteindre un point de barrière commun. Les CyclicBarriers sont utiles dans les programmes impliquant un groupe de threads de taille fixe qui doivent occasionnellement s'attendre les uns les autres. La barrière est appelée
- cyclique
(contrairement à CountDownLatch, qui ne peut pas être réutilisé)car elle peut être réutilisée après la libération des threads en attente, jusqu'à ce que atteigne un certain point de barrière publique . On l'appelle cyclique car lorsque tous les threads en attente sont libérés, CyclicBarrier peut être
réutilisé
CountDownLatch se concentre sur l'attente que d'autres threads se terminent
CyclicBarrier se concentre sur : lorsque le threadatteint un certain état
, il se met en pause et attend d'autres threads2.2 Exemple de barrière cycliqueExemple : 3 ans et sa petite amie ont pris rendez-vous pour aller manger à Guangzhou Ye Shanghai. Puisque 3 ans et la petite amie de 3 ans vivent dans des endroits différents, ils ont pris rendez-vous. est allé naturellement Le chemin est également différent. Ils ont donc convenu de se rencontrer à la station de métro Tiyu West Road
et ont convenu d'envoyer un message à Moments lorsqu'ilsRésultats des tests :
Après avoir joué une journée,import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Test {
public static void main(String[] args) {
final CyclicBarrier CyclicBarrier = new CyclicBarrier(2);
for (int i = 0; i < 2; i++) {
new Thread(() -> {
String name = Thread.currentThread().getName();
if (name.equals("Thread-0")) {
name = "3y";
} else {
name = "女朋友";
}
System.out.println(name + "到了体育西");
try {
// 两个人都要到体育西才能发朋友圈
CyclicBarrier.await();
// 他俩到达了体育西，看见了对方发了一条朋友圈：
System.out.println("跟" + name + "去夜上海吃东西~");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}, 3 ans ont pris rendez-vous avec sa copine
Discutez après que tout le monde ait pris une douche
Résultats des tests :
Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each {@link #acquire} blocks if necessary until a permit is available, and then takes it. Each {@link #release} adds a permit,potentially releasing a blocking acquirer.However, no actual permit objects are used; the {@code Semaphore} just
keeps a count of the number available and acts accordingly.
Semaphore(信号量)实际上就是可以控制同时访问的线程个数，它维护了一组"许可证"。
当调用acquire()方法时，会消费一个许可证。如果没有许可证了，会阻塞起来
当调用release()方法时，会添加一个许可证。
这些"许可证"的个数其实就是一个count变量罢了~
3y女朋友开了一间卖酸奶的小店，小店一次只能容纳5个顾客挑选购买，超过5个就需要排队啦~~~
import java.util.concurrent.Semaphore;
public class Test {
public static void main(String[] args) {
// 假设有50个同时来到酸奶店门口
int nums = 50;
// 酸奶店只能容纳10个人同时挑选酸奶
Semaphore semaphore = new Semaphore(10);
for (int i = 0; i < nums; i++) {
int finalI = i;
new Thread(() -> {
try {
// 有"号"的才能进酸奶店挑选购买
semaphore.acquire();
System.out.println("顾客" + finalI + "在挑选商品，购买...");
// 假设挑选了xx长时间，购买了
Thread.sleep(1000);
// 归还一个许可，后边的就可以进来购买了
System.out.println("顾客" + finalI + "购买完毕了...");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
}输出结果：
反正每次只能5个客户同时进酸奶小店购买挑选。
总结：本文简单的介绍了一下Java多线程的三个同步工具类的用处以及如何用，要深入还得看源码或者查阅其他的资料。如果文章有错的地方欢迎指正，大家互相交流。
相关文章：
相关视频：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
