JUC常用4大并发工具类详解

**JUC常用4大并发工具类详解**

Java.util.concurrent（JUC）包提供了一系列用于构建高性能、可伸缩的多线程应用程序的工具类。其中，四个最常用的工具类是：`Lock`、`Semaphore`、`CountDownLatch` 和 `CyclicBarrier`。本文将详细介绍这些工具类的使用方法和示例代码。

###1. Lock（锁）

`Lock` 接口提供了一个可重入的锁机制，允许线程在执行某个操作时暂停其它线程的访问。`ReentrantLock` 是 `Lock` 接口的一个实现类，它支持多种锁定策略。

####1.1 ReentrantLock（可重入锁）

`ReentrantLock` 支持多种锁定策略，包括公平锁和非公平锁。公平锁保证线程在等待锁的时间内不会被抢占，而非公平锁则允许线程在等待锁的时间内可能被抢占。

javaimport java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
 private static final ReentrantLock lock = new ReentrantLock();

 public void doSomething() {
 // 加锁 lock.lock();
 try {
 System.out.println("正在执行...");
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 } finally {
 //释放锁 lock.unlock();
 }
 }

 public static void main(String[] args) throws InterruptedException {
 ReentrantLockExample example = new ReentrantLockExample();
 Thread thread1 = new Thread(example::doSomething);
 Thread thread2 = new Thread(example::doSomething);

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();
 }
}

####1.2 ReadWriteLock（读写锁）

`ReadWriteLock` 接口提供了一个可重入的读写锁机制，允许多个线程同时读取共享资源，而只允许一个线程修改共享资源。

javaimport java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
 private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

 public void read() {
 // 加读锁 lock.readLock().lock();
 try {
 System.out.println("正在读取...");
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 } finally {
 //释放读锁 lock.readLock().unlock();
 }
 }

 public void write() {
 // 加写锁 lock.writeLock().lock();
 try {
 System.out.println("正在修改...");
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 } finally {
 //释放写锁 lock.writeLock().unlock();
 }
 }

 public static void main(String[] args) throws InterruptedException {
 ReadWriteLockExample example = new ReadWriteLockExample();

 Thread thread1 = new Thread(example::read);
 Thread thread2 = new Thread(example::write);

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();
 }
}

###2. Semaphore（信号量）

`Semaphore` 类提供了一个可重入的信号量机制，允许多个线程等待某个资源的释放。

####2.1 SemaphoreExample

javaimport java.util.concurrent.Semaphore;

public class SemaphoreExample {
 private static final Semaphore semaphore = new Semaphore(3);

 public void doSomething() throws InterruptedException {
 // 等待信号量 semaphore.acquire();
 try {
 System.out.println("正在执行...");
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 } finally {
 //释放信号量 semaphore.release();
 }
 }

 public static void main(String[] args) throws InterruptedException {
 SemaphoreExample example = new SemaphoreExample();

 for (int i =0; i < 10; i++) {
 Thread thread = new Thread(example::doSomething);
 thread.start();
 }

 Thread.sleep(10000);

 System.out.println("结束...");
 }
}

###3. CountDownLatch（倒计时门闩）

`CountDownLatch` 类提供了一个可重入的倒计时门闩机制，允许多个线程等待某个事件的发生。

####3.1 CountDownLatchExample

javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
 private static final int COUNT =5;
 private static final CountDownLatch latch = new CountDownLatch(COUNT);

 public void doSomething() throws InterruptedException {
 // 等待倒计时门闩 latch.await();
 System.out.println("事件发生...");
 }

 public static void main(String[] args) throws InterruptedException {
 CountDownLatchExample example = new CountDownLatchExample();

 for (int i =0; i < COUNT; i++) {
 Thread thread = new Thread(example::doSomething);
 thread.start();
 }

 // 等待所有线程执行完成 Thread.sleep(10000);

 System.out.println("结束...");
 }
}

###4. CyclicBarrier（循环栅栏）

`CyclicBarrier` 类提供了一个可重入的循环栅栏机制，允许多个线程等待某个事件的发生。

####4.1 CyclicBarrierExample

javaimport java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
 private static final int COUNT =5;
 private static final CyclicBarrier barrier = new CyclicBarrier(COUNT);

 public void doSomething() throws InterruptedException, BrokenBarrierException {
 // 等待循环栅栏 barrier.await();
 System.out.println("事件发生...");
 }

 public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
 CyclicBarrierExample example = new CyclicBarrierExample();

 for (int i =0; i < COUNT; i++) {
 Thread thread = new Thread(example::doSomething);
 thread.start();
 }

 // 等待所有线程执行完成 Thread.sleep(10000);

 System.out.println("结束...");
 }
}

本文介绍了JUC包中四个最常用的工具类：`Lock`、`Semaphore`、`CountDownLatch` 和 `CyclicBarrier`。这些工具类可以帮助开发者构建高性能、可伸缩的多线程应用程序。