Java高并发(三)——多线程协作，同步控制

本文链接：https://blog.csdn.net/liujiahan629629/article/details/84312204

本文介绍了Java高并发中的多线程协作与同步控制，包括ReentrantLock重入锁的特性，如中断响应、公平锁等；Condition条件的等待与通知功能；Semaphore信号量实现多线程同时访问；ReadWriteLock读写锁解决读写冲突；CountDownLatch倒计时器等待子线程执行完成；CyclicBarrier循环栅栏的循环使用特性；以及LockSupport的park()和unpark()方法实现线程阻塞与唤醒。这些工具能够有效管理共享资源，确保多线程环境中的数据一致性。

摘要由CSDN通过智能技术生成

继上一篇：Java高并发——多线程基础中讲到，共享资源的合理使用，才能够使多线程程序有条不紊的运行。其中我们通过synchronized来实现临界区资源的是否可以访问。而，这篇我们来重点总结synchronized的增强替代版锁，以及其它JDK并发包提供的一些同步控制的功能。

好，还是先看下知识的总结思维导图，然后分开进行总结：

一，ReentrantLock（重入锁）：1，顾名思义就是像一把锁，我们可以锁住，又可以打开，从而控制资源的同步访问。而其中重入特性指的是同一个线程，可以反复的进入；2，中断响应，对于synchronized只有保持等待，和继续执行两种情况；而ReentrantLock在等待的过程，我们可以通知其放弃等待（类似生活中约会，你等了一会朋友没到，但是朋友遇到突发情况不能来了，给你打了电话通知你，你就不等了）；3，申请等待时间：就是指定等待时间，在指定时间没得到，则放弃；4，公平锁：指定fair为true则进行先到先得，而不是随机选取。这里看下ReentrantLock的相关例子：

//1,ReentrantLock例子
public class ReentrantLockTest implements Runnable{
    public static ReentrantLock lock  =new ReentrantLock();

    public static int i =0;

    public void run() {
        for (int j = 0; j < 1000; j++) {
            lock.lock();
            //lock.lock();
            try {
                i++;
            }finally {
                lock.unlock();
                //lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();
        Thread t1 = new Thread(reentrantLockTest);
        Thread t2 = new Thread(reentrantLockTest);

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}


//2，lock1.lockInterruptibly()中断后可放弃
public class InterruptLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();

    int lock;

    public InterruptLock(int lock) {
        this.lock = lock;
    }

    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                Thread.sleep(500);
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                Thread.sleep(500);
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();
            }
            System.out.println(Thread.cu