Résumé des points de connaissances sur trois outils de synchronisation des threads Java, notes de collection

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~

1. 🎜>

1.1 Introduction à CountDownLatch

• 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.

En termes simples : CountDownLatch est une classe auxiliaire synchronisée qui

permet à un ou plusieurs threads d'attendre jusqu'à ce que d'autres threadsterminentleurs opérations . Il existe en fait deux API couramment utilisées :

et

await()countDown()

Instructions d'utilisation :

count initialise CountDownLatch, puis le thread qui doit attendre appelle la méthode wait. La méthode wait se bloquera jusqu'à ce que count=0. Une fois que les autres threads ont terminé leurs opérations, appelez
• pour décrémenter le nombre de compteurs de 1.

  Lorsque le nombre diminue à 0, tous les threads en attente seront libéréscountDown()

Pour parler franchement, l'attente est contrôlée via la
• variable count

  . la valeur du compte est 0 (les tâches des autres threads sont terminées), alors l'exécution peut continuer.

1.2 Exemple de CountDownLatch

Exemple : 3 ans travaille maintenant comme stagiaire et les autres employés n'ont pas encore quitté le travail. 3 ans est trop gêné pour partir en premier. , en attendant le départ de tous les autres salariés. Il reste 3 jours avant de partir.

Résultat de sortie :

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.

Les autres employés doivent attendre que 3 ans soient terminés avant de pouvoir continuer à écrire.

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

2.1 Introduction à CyclicBarrier

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

  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é
(contrairement à CountDownLatch, qui ne peut pas être réutilisé)

Mode d'emploi :

CountDownLatch se concentre sur l'attente que d'autres threads se terminent

CyclicBarrier se concentre sur : lorsque le thread

atteint un certain état

, il se met en pause et attend d'autres threads

. Tous les threads arrivent Dans le futur
• , continuez l'exécution.

  2.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'ils
se sont rencontrés

.

Ré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();
        }
    }
}

chacun est rentré chez lui

, 3 ans ont pris rendez-vous avec sa copine

Discutez après que tout le monde ait pris une douche

Résultats des tests :

三、Semaphore

3.1Semaphore简介

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变量罢了~

3.2Semaphore例子

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多线程的三个同步工具类的用处以及如何用，要深入还得看源码或者查阅其他的资料。如果文章有错的地方欢迎指正，大家互相交流。

相关文章：

Java基础之线程同步

关于Java线程同步和同步方法的详解

相关视频：

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!