java线程同步CoutDownLatch、CylicBarrier、Semsphore

拼搏现实的明天。 2023-10-11 00:38 2阅读 0赞

## CountDownLatch ##

CountDownLatch是Java并发包(java.util.concurrent)中的一种同步工具，它允许一个或多个线程等待其他线程完成任务后再执行。CountDownLatch通常用于在多线程环境下协调任务的执行顺序。

CountDownLatch的基本用法如下：

1.  创建一个CountDownLatch实例：

import java.util.concurrent.CountDownLatch;
    
    public class CountDownLatchExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            CountDownLatch latch = new CountDownLatch(3); // 初始化CountDownLatch,需要3个线程调用countDown()方法
    
            Thread thread1 = new Thread(new Task(latch, "Thread 1"));
            Thread thread2 = new Thread(new Task(latch, "Thread 2"));
            Thread thread3 = new Thread(new Task(latch, "Thread 3"));
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }
    
    class Task implements Runnable {
        
    
        private final CountDownLatch latch;
        private final String name;
    
        public Task(CountDownLatch latch, String name) {
        
            this.latch = latch;
            this.name = name;
        }
    
        @Override
        public void run() {
        
            try {
        
                System.out.println("Task " + name + " is running");
                Thread.sleep(1000); // 模拟任务执行时间
                System.out.println("Task " + name + " completed");
                latch.countDown(); // 当计数器减至0时，所有等待的线程将被唤醒
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

在这个示例中，我们创建了一个名为CountDownLatchExample的类。main()方法中，我们创建了一个CountDownLatch实例，并为3个线程分别分配了任务。然后，我们启动这3个线程。每个线程在完成任务后调用CountDownLatch的countDown()方法，当计数器减至0时，主线程将被唤醒。

## CyclicBarrier ##

CyclicBarrier是Java并发包(java.util.concurrent)中的一种同步工具，它允许一组线程在达到某个共享状态时一起阻塞。CyclicBarrier主要用于协调多个线程之间的顺序执行或同步。

CyclicBarrier的基本用法如下：

1.  创建一个CyclicBarrier实例：

import java.util.concurrent.CyclicBarrier;
    
    public class CyclicBarrierExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            CyclicBarrier barrier = new CyclicBarrier(3); // 初始化CyclicBarrier,需要3个线程调用await()方法
    
            Thread thread1 = new Thread(new Task(barrier, "Thread 1"));
            Thread thread2 = new Thread(new Task(barrier, "Thread 2"));
            Thread thread3 = new Thread(new Task(barrier, "Thread 3"));
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }
    
    class Task implements Runnable {
        
    
        private final CyclicBarrier barrier;
        private final String name;
    
        public Task(CyclicBarrier barrier, String name) {
        
            this.barrier = barrier;
            this.name = name;
        }
    
        @Override
        public void run() {
        
            try {
        
                System.out.println("Task " + name + " is running");
                Thread.sleep(1000); // 模拟任务执行时间
                System.out.println("Task " + name + " completed");
                barrier.await(); // 当所有线程都到达屏障时，主线程将被唤醒
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

在这个示例中，我们创建了一个名为CyclicBarrierExample的类。main()方法中，我们创建了一个CyclicBarrier实例，并为3个线程分别分配了任务。然后，我们启动这3个线程。每个线程在完成任务后调用CyclicBarrier的await()方法，当所有线程都到达屏障时，主线程将被唤醒。

## Semaphore ##

Semaphore是Java并发包(java.util.concurrent)中的一种同步工具，它允许一组线程在达到某个共享状态时进行互斥访问。Semaphore有两个重要类型：

1.  Semaphore:Semaphore是一个计数信号量，用于控制同时访问的线程数量。创建一个Semaphore实例时，可以指定初始值和最大值。当一个线程尝试获取信号量时，如果计数小于最大值，则计数加1;否则，线程将等待直到计数减少到可用值。
2.  CountDownLatch:CountDownLatch也是一个计数信号量，但它允许一个或多个线程在到达某个共享状态后继续执行。创建一个CountDownLatch实例时，可以指定初始值。当一个或多个线程调用countDown()方法时，计数减1。当计数变为0时，所有等待的线程都将被唤醒。

下面是Semaphore的示例代码：

import java.util.concurrent.Semaphore;
    
    public class SemaphoreExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            int initialValue = 5; // 初始化Semaphore,允许5个线程同时访问
            int maxValue = 10; // 最大允许访问的线程数为10
            Semaphore semaphore = new Semaphore(initialValue, maxValue); // 创建一个Semaphore实例，初始值为5,最大值为10
    
            Thread thread1 = new Thread(new Task(semaphore));
            Thread thread2 = new Thread(new Task(semaphore));
            Thread thread3 = new Thread(new Task(semaphore));
            Thread thread4 = new Thread(new Task(semaphore));
    
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
        }
    }
    
    class Task implements Runnable {
        
    
        private final Semaphore semaphore;
    
        public Task(Semaphore semaphore) {
        
            this.semaphore = semaphore;
        }
    
        @Override
        public void run() {
        
            try {
        
                semaphore.acquire(); // 尝试获取信号量，如果可用则计数加1,否则等待直到可用
                System.out.println("Thread " + Thread.currentThread().getName() + " is running");
                Thread.sleep(1000); // 模拟任务执行时间
                semaphore.release(); // 释放信号量，计数减1
                System.out.println("Thread " + Thread.currentThread().getName() + " completed");
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

## CoutDownLatch和CylicBarrier区别 ##

CountDownLatch和CyclicBarrier都是Java并发包(java.util.concurrent)中用于协调多个线程之间同步的工具，但它们在实现上有所不同。

1.  CountDownLatch  
    CountDownLatch是一个计数信号量，允许一个或多个线程在到达某个共享状态后继续执行。当一个或多个线程调用countDown()方法时，计数减1。当计数变为0时，所有等待的线程都将被唤醒。CountDownLatch通常与Semaphore一起使用，以控制同时访问的资源数量。

示例代码：

import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.Semaphore;
    
    public class CountDownLatchExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            int initialValue = 5; // 初始化CountDownLatch,允许5个线程同时执行countDown()方法
            int maxValue = 10; // 最大允许执行的线程数为10
            CountDownLatch countDownLatch = new CountDownLatch(initialValue); // 创建一个CountDownLatch实例，初始值为5
    
            for (int i = 0; i < initialValue; i++) {
        
                new Thread(new Task(countDownLatch)).start(); // 创建多个线程，每个线程都调用countDown()方法
            }
    
            countDownLatch.await(); // 所有线程执行完countDown()方法后，主线程才会继续执行
            System.out.println("All threads completed");
        }
    }
    
    class Task implements Runnable {
        
    
        private final CountDownLatch countDownLatch;
    
        public Task(CountDownLatch countDownLatch) {
        
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
        
            try {
        
                countDownLatch.countDown(); // 每调用一次countDown()方法，计数减1
                System.out.println("Thread " + Thread.currentThread().getName() + " is running");
                Thread.sleep(1000); // 模拟任务执行时间
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } finally {
        
                countDownLatch.countDown(); // 在finally块中再次调用countDown()方法，确保所有线程都执行完countDown()方法后计数减1
            }
        }
    }

CoutDownLatch是所有子线程都准备好后再同时开始，而CyclicBarrier是所有线程结束后再一起回到主线程。