Java同步机制

一、倒数门闩CountDownLatch

CountDownLatch是基于AbstractQueuedSynchronizer（AQS，抽象队列同步器）实现的。

• CountDownLatch的使用

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 定义一个变量result，初始化为0
 * 创建100个线程，每个线程都对result变量进行100次加1操作
 * 最后在主线程中输出result的值（正确的值应为10000）
 * @author IT00ZYQ
 * @Date 2021/3/4 11:05
 **/
public class T03_CountDownLatch {
    private static int COUNT = 100;
    private static AtomicInteger result = new AtomicInteger();


    public static void main(String[] args) {
        // 倒数门闩，需要count为0时才能通过
        CountDownLatch latch = new CountDownLatch(COUNT);
        Thread[] threads = new Thread[COUNT];

        // 创建COUNT个线程
        for (int i = 1; i <= COUNT; i++) {
            int t = i;
            threads[i - 1] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    result.incrementAndGet();
                }
                System.out.println("执行倒数, 当前线程: " + t);
                // 每个线程执行完成后，都会对latch进行减1操作
                latch.countDown();
            });
        }

        // 启动COUNT个线程
        for (int i = 0; i < COUNT; i++) {
            threads[i].start();
        }

        try {
            // 添加门闩，只有countdown为0时才能通过
            // 因为CountDownLatch的初始值为100,
            // 且每个线程执行完成后只会执行一次countDown();操作
            // 所以这里只有上面100个线程都执行完成才会继续往下执行
            latch.await();
            System.out.println("CountDownLatch倒数结束，阀门开启");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 因为有latch.await()，可以保证100个线程都已执行完成，这里的结果是正确的
        System.out.println("atomicInteger = " + result);

    }
}

二、信号量Semaphore

Semaphore是基于AbstractQueuedSynchronizer（AQS，抽象队列同步器）实现的。

• Semaphore的使用

import java.util.concurrent.Semaphore;

/**
 * @author IT00ZYQ
 * @Date 2021/3/4 11:36
 **/
public class T05_Semaphore {
    /**
     * 信号量，只有信号量大于0时才能拿到锁
     */
    static Semaphore s = new Semaphore(4);

    static void testRun() {
        try {
            // 拿到锁需要的信号量，默认为1
            s.acquire();
            System.out.println(Thread.currentThread().getName() + "成功获取信号量");
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName() + "运行结束，释放信号量");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放信号量
            s.release();
        }
    }

    public static void main(String[] args) {

        new Thread(() -> testRun(), "t1").start();
        new Thread(() -> testRun(), "t2").start();
        new Thread(() -> testRun(), "t3").start();
        new Thread(() -> testRun(), "t4").start();
        new Thread(() -> testRun(), "t5").start();

    }
}

运行结果：

t1成功获取信号量
t2成功获取信号量
t3成功获取信号量
t4成功获取信号量
t1运行结束，释放信号量
t5成功获取信号量
t2运行结束，释放信号量
t3运行结束，释放信号量
t4运行结束，释放信号量
t5运行结束，释放信号量

Process finished with exit code 0

因为信号量只有4，每个线程的运行都需要获取1个信号量，所有第5个线程必须等待有线程释放了信号量才能开始运行。

三、读写锁ReentrantReadWriteLock

ReentrantReadWriteLock是基于两个AQS实现的，ReadLock与WriteLock是两个不同的AQS。

• ReentrantReadWriteLock的使用

import juc.utils.SleepUtil;

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

/**
 * @author IT00ZYQ
 * @Date 2021/3/4 11:24
 **/
public class T06_ReadWriteLock {
    /**
     * 读写锁
     * 读锁是共享锁
     * 写锁是排他锁
     */
    static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static Lock readLock = readWriteLock.readLock();
    static Lock writeLock = readWriteLock.writeLock();

    static void read(Lock lock) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始Read操作");
            SleepUtil.sleepSecond(5);
            System.out.println(Thread.currentThread().getName() + "Read操作结束");
        } finally {
            lock.unlock();
        }
    }

    static void write(Lock lock) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始Write操作");
            SleepUtil.sleepSecond(3);
            System.out.println(Thread.currentThread().getName() + "Write操作结束");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        new Thread(() -> read(readLock), "Read-01").start();
        new Thread(() -> read(readLock), "Read-02").start();
        new Thread(() -> write(writeLock), "Write-01").start();
        new Thread(() -> write(writeLock), "Write-02").start();
        new Thread(() -> read(readLock), "Read-03").start();
        new Thread(() -> read(readLock), "Read-04").start();
    }
}

运行结果：

Read-01开始Read操作
Read-02开始Read操作
Read-02Read操作结束
Read-01Read操作结束
Write-01开始Write操作
Write-01Write操作结束
Write-02开始Write操作
Write-02Write操作结束
Read-03开始Read操作
Read-04开始Read操作
Read-04Read操作结束
Read-03Read操作结束

Process finished with exit code 0

分析运行结果，一个写操作的开始到写操作结束，不会有其他的读操作或写操作；而多个读操作是不会相互影响的。简单来说，读锁是共享锁，写锁是排他锁。

四、线程阻塞工具LockSupport

类似于同步代码块中的wait()与notify()，LockSupport中有park()与unpark()，主要用户线程间通信。底层调用了Unsafe类中的方法。

• LockSupport的使用

package juc;

import java.util.concurrent.locks.LockSupport;

/**
 * @author IT00ZYQ
 * @Date 2021/3/4 15:34
 **/
public class T07_LockSupport {

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t1线程: " + i);
                if (i == 5) {
                    System.out.println("线程t1 park()等待线程t2运行结束...");
                    // 停车
                    LockSupport.park();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("t2线程: " + i);
            }
            System.out.println("线程t2运行结束, unPark() t1...");
            LockSupport.unpark(t1);
        });

        t1.start();
        t2.start();
    }
}

运行结果：

1线程: 0
t1线程: 1
t1线程: 2
t2线程: 0
t1线程: 3
t2线程: 1
t2线程: 2
t2线程: 3
t2线程: 4
t2线程: 5
t2线程: 6
t2线程: 7
t2线程: 8
t1线程: 4
t1线程: 5
t2线程: 9
线程t2运行结束, unPark() t1...
线程t1 park()等待线程t2运行结束...
t1线程: 6
t1线程: 7
t1线程: 8
t1线程: 9

Process finished with exit code 0

t1线程运行到i = 5时，调用了park()方法，此时线程1会进入WAIT状态，等待t2线程对t1线程进行unpark()之后t1线程才能继续运行。所以这里的t2线程打印完最后一个数9之后，t1线程才有可能打印 6~9 的数。