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

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("所有线程任务已经执行完成！");
    }

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

# 🎜🎜#

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

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.

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!