线程安全
AbstractQueuedSynchronizer 类
又名 AQS 框架，位于 java.util.concurrent.locks 包内。用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock，Semaphore 等。
AQS 核心思想是通过以下方式，建立一套线程阻塞等待以及被唤醒时锁分配的机制。
CLH 不存在真实的队列，仅存在结点之间的关联关系。
AQS 存储状态
AQS 负责维护：
一个 volatile int 成员变量 state
一个 FIFO 线程等待队列
成员变量 state 表示资源状态，通过 getState/setState 方法存取。
线程抢占资源时会通过 CAS 操作去尝试修改 state ，成功则获取锁成功，失败则进入等待队列等待被唤醒。
资源共享方式
AQS 定义两种资源共享方式
只有一个线程能执行，如 ReentrantLock。
state 初始化为 0，表示未锁定状态。加一后锁定。
多个线程可同时执行，如 Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 。
返回 state 负数表示失败；0 表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
自定义同步器
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：
同步类在实现时一般都将自定义同步器（sync）定义为内部类，供自己使用；而同步类自己（Mutex）则实现某个接口，对外服务。
使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放） 将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
isHeldExclusively()：该线程是否正在独占资源。只有用到 condition 才需要去实现它。 tryAcquire(int)：独占方式。尝试获取资源，成功则返回 true，失败则返回 false。 tryRelease(int)：独占方式。尝试释放资源，成功则返回 true，失败则返回 false。 tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0 表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。 tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回 true，否则返回 false。
class Mutex implements Lock, java.io.Serializable { // 自定义同步器 private static class Sync extends AbstractQueuedSynchronizer { // 判断是否锁定状态 protected boolean isHeldExclusively() { return getState() == 1; }
// 尝试获取资源，立即返回。成功则返回true，否则false。 public boolean tryAcquire(int acquires) { assert acquires == 1; // 这里限定只能为1个量 if (compareAndSetState(0, 1)) {//state为0才设置为1，不可重入！ setExclusiveOwnerThread(Thread.currentThread());//设置为当前线程独占资源 return true; } return false; }
// 尝试释放资源，立即返回。成功则为true，否则false。 protected boolean tryRelease(int releases) { assert releases == 1; // 限定为1个量 if (getState() == 0)//既然来释放，那肯定就是已占有状态了。只是为了保险，多层判断！ throw new IllegalMonitorStateException(); setExclusiveOwnerThread(null); setState(0);//释放资源，放弃占有状态 return true; } }
// 真正同步类的实现都依赖继承于AQS的自定义同步器！ private final Sync sync = new Sync();
//lock<-->acquire。两者语义一样：获取资源，即便等待，直到成功才返回。 public void lock() { sync.acquire(1); }
//tryLock<-->tryAcquire。两者语义一样：尝试获取资源，要求立即返回。成功则为true，失败则为false。 public boolean tryLock() { return sync.tryAcquire(1); }
//unlock<-->release。两者语文一样：释放资源。 public void unlock() { sync.release(1); }
//锁是否占有状态 public boolean isLocked() { return sync.isHeldExclusively(); }}Copy to clipboardErrorCopied
复制代码
ReentrantReadWriteLock 锁
Java 的并发包提供了读写锁 ReentrantReadWriteLock ，其拥有两个锁：读锁-共享锁；写锁-排他锁。如果其他线程没有持有写锁，线程就能获得读锁。而只有其他线程没有持有任何锁，线程才能获得写锁。这样在没有写操作的时候，允许多个线程同时读一个资源，提高并发效率。
一个线程要想同时持有写锁和读锁，必须先获取写锁再获取读锁；写锁可以降级为读锁；读锁不能升级为写锁。
Semaphore 信号量
Semaphore 类是一个同步工具类，需要进行导入：import java.util.concurrent.Semaphore。
synchronized 和 ReentrantLock 一次只允许一个线程访问某个资源，如果指定多个线程同时访问某个资源需要钱使用 Semaphore 类。线程执行时调用 acquire 方法申请信号量，如果剩余信号量不足则必须等待其他线程执行完毕后调用 release 方法释放信号量。
Semaphore 方法
Semaphore semaphore = new Semaphore(0); Semaphore semaphore = new Semaphore(20, true);
// Semaphore 构造方法设定了初始信号量，可以为 0。默认为非公平锁，设定属性 true 则为公平锁。
semaphore.acquire(); // 线程获取一个信号量semaphore.acquire(5); // 线程获取五个信号量
semaphore.release(); // 线程释放一个信号量semaphore.release(5); // 线程释放五个信号量
semaphore.availablePermits(); // 读取剩余信号量Copy to clipboardErrorCopied
复制代码
Semaphore 示例
public class SemaphoreExample1 {
public static void main(String[] args) throws InterruptedException { ExecutorService threadPool = Executors.newFixedThreadPool(300); // 设置 20 个信号量 final Semaphore semaphore = new Semaphore(20); // final Semaphore semaphore = new Semaphore(20, true); 公平锁
for (int i = 0; i < 500; i++) { final int threadnum = i; threadPool.execute(() -> { try { semaphore.acquire(); // 获取一个信号量 test(threadnum); semaphore.release(); // 释放一个信号量 } catch (InterruptedException e) { e.printStackTrace(); }
}); } threadPool.shutdown(); System.out.println("finish"); }
public static void test(int threadnum) throws InterruptedException { Thread.sleep(1000); System.out.println("threadnum:" + threadnum); Thread.sleep(1000); }}Copy to clipboardErrorCopied
复制代码
CountDownLatch 倒计时器
CountDownLatch 类是一个同步工具类，需要进行导入：import java.util.concurrent.CountDownLatch。
其通过 await 方法设置一个屏障，线程到达后被阻塞。直到其他线程调用 countDown 方法达到 N 次后才允许向后执行。 CountDownLatch 类是一次性的，计数器值只能在构造方法中初始化一次，不能被重复使用。常用来协同多个线程之间的执行顺序，比如主线程需要等待多个组件加载完毕之后再继续执行。
CountDownLatch 方法
CountDownLatch latch = new CountDownLatch(5);
// CountDownLatch 构造方法设定了门闩个数。
latch.countDown(); // 解锁门闩，门闩个数减一latch.await(); // 线程等待门闩，个数为 0 后向后执行Copy to clipboardErrorCopied
复制代码
CountDownLatch 示例
import java.util.concurrent.CountDownLatch;
public class ThreadDemo {
final static CountDownLatch latch = new CountDownLatch(5);
public static void main(String[] args) throws InterruptedException { for(int i = 0; i < 5; i++) { new MyThread().start(); } latch.await(); System.out.println("主线程继续执行"); }
static class MyThread extends Thread { @Override public void run() { try { System.out.println(getName() + "打开门闩"); } finally { latch.countDown(); } } }}Copy to clipboardErrorCopied
复制代码
CyclicBarrier 循环栅栏
CyclicBarrier 类也是一个同步工具类，需要进行导入：import java.util.concurrent.CyclicBarrier。
其通过 await 方法设置一个屏障，线程到达后被阻塞。只有当 N 个线程都到达屏障后才允许这些线程向后执行。和 CountDownLatch 不同，CyclicBarrier 可循环利用。常用于多线程计算数据，最后合并计算结果的场景。
CyclicBarrier 方法
CyclicBarrier barrier = CyclicBarrier(10); CyclicBarrier barrier = CyclicBarrier(10, ()-> System.out.println("open"));
// CyclicBarrier 构造方法设定了参与线程的个数 N，也可以选择设定在第 N 个线程到达屏障时执行方法。
barrier.await(); // 线程必须等到 N 个线程才能向后执行barrier.await(20, TimeUnit.SECONDS); // 线程等待规定时间后无论如何都会向后执行Copy to clipboardErrorCopied
复制代码
CyclicBarrier 示例
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo { public static void main(String[] args) { for(int i = 0; i < 10; i++) { new MyThread().start(); } } }
class MyThread extends Thread { static CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() { @Override public void run() { System.out.println("栅栏开启"); } });
@Override public void run() { try { Thread.sleep(1000); System.out.println(getName() + " 到达栅栏"); barrier.await(); System.out.println(getName() + " 冲破栅栏"); } catch (Exception e) { e.printStackTrace(); } }}
复制代码
评论