Pour implémenter la synchronisation des signaux dans les tâches collaboratives multithread Java, vous pouvez utiliser les méthodes suivantes :-javaDidacticiel-php.cn

Pour implémenter la synchronisation des signaux dans les tâches collaboratives multithread Java, vous pouvez utiliser les méthodes suivantes :

WBOY

Libérer： 2023-05-09 10:07:08

avant

1348 Les gens l'ont consulté

1. Synchronisation du signal

Plusieurs threads sont souvent des opérations collaboratives. Par exemple, quatre fils de discussion collectent chaque trimestre des statistiques sur les données du commerce électronique. Une fois les statistiques terminées, elles sont résumées. Comment savoir que les quatre threads ont été exécutés ? Nous pouvons utiliser les classes auxiliaires CountDownLatch (

Reduce count), CyclicBarrier (barrière cyclique) et Semaphore (sémaphore) qui nous sont fournies par JDK1.5.

2. Basé sur la dimension temporelle

1 CountDownLatch

Le nombre de threads coopérants détermine le nombre de paramètres de construction de CountDownLatch qui sont initialisés.

 public static void main(String[] args) throws InterruptedException {
        final int NUM=6;
        //定义总数量；
        CountDownLatch countDownLatch=new CountDownLatch(NUM);
        for (int i = 0; i < NUM; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"线程，已执行！");
                //减少计数
                countDownLatch.countDown();
            },String.valueOf(i+1)).start();
        }
        //等待所有任务完成
        countDownLatch.await();
        System.out.println("所有线程任务已经执行完成！");
    }

Copier après la connexion

Pour implémenter la synchronisation des signaux dans les tâches collaboratives multithread Java, vous pouvez utiliser les méthodes suivantes :

2, CyclicBarrier

est similaire à la réduction du nombre

 public static void main(String[] args) {
        final int NUM = 6;
        //定义循环数量及循环完成后的任务(Runnable接口实现)；
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUM, () -> {
            System.out.println("所有线程任务已经执行完成！");
        });
        for (int i = 0; i < NUM; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"线程，已执行！");
                try {
                    //等待点或障碍点，等待所有任务完成，
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i+1)).start();
        }
    }

Copier après la connexion

Pour implémenter la synchronisation des signaux dans les tâches collaboratives multithread Java, vous pouvez utiliser les méthodes suivantes : # 🎜🎜#

3. Basé sur la dimension du signal

Semaphore, le fil et le signal sont m:n, où m>=n.

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/*信号灯
* 6个线程，抢占三个信号
* */
public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    //获取信号
                    semaphore.acquire();
                    System.out.println("线程："+Thread.currentThread().getName()+"----获取信号");
                    int time = new Random().nextInt(5);
                    System.out.println(("线程："+Thread.currentThread().getName()+"----休眠"+time+"s！"));
                    TimeUnit.SECONDS.sleep(time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                //    释放信号
                    System.out.println("线程："+Thread.currentThread().getName()+"---释放信号");
                    semaphore.release();
                }
            },String.valueOf(i+1)).start();
        }
    }
}

Copier après la connexion

Tout d'abord, les threads 4, 1 et 3 reçoivent le signal. Après que le thread 1 ait libéré le signal, le thread 2 reçoit le signal. Une fois que les threads 2 et 3 ont libéré le signal, les threads 5 et 6 reçoivent le signal.

Pour implémenter la synchronisation des signaux dans les tâches collaboratives multithread Java, vous pouvez utiliser les méthodes suivantes :