关于JDK中线程同步类的学习

约定不等于承诺〃 2023-09-25 22:57 38阅读 0赞

![format_png][]

本文主要从锁的分类来分别描述`JDK`中`ReentrantLock、Semaphore、ReentrantReadWrite`类的使用，本文主要有以下内容：

>  *  可重入锁
>  *  悲观锁和乐观锁
>  *  读写锁
>  *  公平锁

**注：** **锁只是一种性质，并不互斥，即一个锁可以是可重入锁，同时也可以是悲观锁，或者互斥锁或者独占锁。**

首先明确以下概念：

**可重入锁：** 当一个锁被线程持有后，该锁仍能被当前线程成功申请。即线程可以重复获得同一个锁。Java中的内置锁都是可重入锁如`synchronized`修饰的代码块，`ReentrantLock`类等。

**悲观锁：** 一个线程进入临界资源，会造成"自己"状态的变化，因此不允许其他线程进入，只有等到当前线程出了临界区(释放掉锁资源)之后，才允许其他线程进入。也可以称之为独占锁。如`synchronized` 修饰的代码 或者`ReentrantLock`修饰的代码

**乐观锁**：指的是临界区的代码允许多个线程同时访问，不担心会对我的状态发生变化，从而导致的线程安全问题。如读写锁。允许多个线程同时读。

**读写锁**：从对状态的操作上来定义，如去访问一个值不会修改这个值这样的行为称为**读**，为这种行为加的锁叫**读锁**，反之当去修改一个值称为写操作，加的锁为**写锁**

读写锁具有如下性质：

>  *  读读操作不阻塞
>  *  读写操作会阻塞,写会阻塞读操作
>  *  写写操作也会堵塞

**公平锁：** 按照先来后到的顺序依次获得临界资源

## ReentrantLock ##

这一部分主要涉及以下内容

>  *  `synchronized`
>  *  `ReentrantLock`
>     
>      *  `lock()`: 获得锁，得不到则等待
>      *  `unlock()`：释放锁
>      *  `lockInterruptibly()`：获得锁，得不到则等待，优先响应中断
>      *  `tryLock()`：尝试去获得锁，立马返回结果，申请成功则返回true，否则返回false
>      *  `tryLock(timeout,TimeUnit)`：在指定时间内去尝试申请锁，申请返回true否则返回false

需要关注的是：申请锁之后必须手动调用`unlock()`去执释放锁，否则该锁得不到释放，其他线程无法获取资源

### ReentrantLock::lock/unlock ###

在[不得不说的Java线程中的那些事][Java]一文中，描述了`synchronized`关键字的作用

>  *  保证了可见性，原子性，以及有序性。

在这里做一个补充说明，`synchronized`可用于修饰如下代码

>  *  修饰非静态方法，此时这个锁对象是调用方法的实例
>  *  修饰静态方法，此时锁对象是静态方法所在类
>  *  出现在方法内部，修饰的局部代码段，此时锁对象是传入的对象

以修饰非静态方法为例演示"**重入**"现象

public class ReentrantDemo {
        public static void main(String[] args) {
            new ReentrantDemo().sayHello();
        }
        public synchronized void sayHello(){
            System.out.println("hello hi");
            sayHi();
        }
        public synchronized void sayHi(){
            System.out.println("hi hello");
        }
        // output：hello hi 
        //         hi hello
    }
    复制代码

运行结果表明：`synchronized`关键字修饰两个方法如果是不可从重入的，则在打印完`hello hi`之后，线程就应该阻塞，而不应该打印出`hi hello`，下面以ReentrantLock为例：

public class ReentrantLockDemo implements Runnable {
    
        public static ReentrantLock reentrantLock = new ReentrantLock();
        public static int i = 0;
        @Override
        public void run() {
            try {
                reentrantLock.lock();
                reentrantLock.lock();
                for (int j = 0; j < 100000; j++) {
                    i++;
                }
            } finally {
                reentrantLock.unlock();
                reentrantLock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
        Thread threadA = new Thread(reentrantLockDemo);
        Thread threadB = new Thread(reentrantLockDemo);
        threadA.start();
        threadB.start();
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(ReentrantLockDemo.i); 
        //output:200000
    }
    复制代码

从运行结果`200000`可以看到`reentrantLock.lock();`出现了两次，也表明`ReentrantLock`也是一个可重入锁。

`synchronized`和`ReentrantLock`具有可重入锁这个性质，在`JDK1.5`以前`ReentrantLock`的性能要优于`synchronized`，但是在`JDK6.0`之后，`synchronized`得到很大的优化，使得二者性能相差不大。

### ReentrantLock::LockInterruptibly ###

`lockInterruptibly`方表示在申请的过程中，优先响应中断，以如下代码为例

public class ReentrantLockInterruptDemo implements Runnable {
        public static ReentrantLock lock1 = new ReentrantLock();
        public static ReentrantLock lock2 = new ReentrantLock();
        private int flag;
        public ReentrantLockInterruptDemo(int flag) {
            this.flag = flag;
        }
        @Override
        public void run() {
            if (flag == 1) {
                try {
                    lock1.lockInterruptibly();
                    Thread.sleep(3000);
                    try {
                        lock2.lockInterruptibly();
                        System.out.println(Thread.currentThread().getName() + " my job done");
                    } finally {
                        lock2.unlock();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock1.unlock();
                }
            } else {
                try {
                    lock2.lockInterruptibly();
                    Thread.sleep(3000);
                    try {
                        lock1.lockInterruptibly();
                        System.out.println(Thread.currentThread().getName() + " my job done");
                    } finally {
                        lock1.unlock();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock2.unlock();
                }
            }
    
        }
        public static void main(String[] args) throws InterruptedException {
            ReentrantLockInterruptDemo reentrantLockInterruptDemo = new ReentrantLockInterruptDemo(1);
            ReentrantLockInterruptDemo reentrantLockInterruptDemo2 = new ReentrantLockInterruptDemo(2);
            Thread thread = new Thread(reentrantLockInterruptDemo,"first");
            Thread thread2 = new Thread(reentrantLockInterruptDemo2,"second");
            thread.start();
            thread2.start();
            Thread.sleep(1000);
            thread2.interrupt();
        }
    }
    
    复制代码

线程先申请lock1然后睡眠3s在去申请lock2，反之线程2先申请lock2在申请lock1，这样就构造出了一个死锁条件。此时中断thread1得到如下输出

![format_png 1][]

可以看到线程2得到成功运行，线程1响应中断。线程1并没有输出 `first my job done`

### ReentrantLock::tryLock ###

`Reentrant::tryLock`尝试去获取一个锁，立马返回结果

public class ReentrantLockTryLockDemo implements Runnable {
        private static ReentrantLock lock1 = new ReentrantLock();
        private static ReentrantLock lock2 = new ReentrantLock();
        private int flag;
        public ReentrantLockTryLockDemo(int flag) {
            this.flag = flag;
        }
        @Override
        public void run() {
    
            if (flag == 1) {
                if (lock1.tryLock()) {
                    System.out.println(Thread.currentThread().getName() + "得到lock1");
                    try {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        boolean b = lock2.tryLock();
                        System.out.println(Thread.currentThread().getName() + "lock2的申请结果：" + b);
                        if (b) {
                            try {
                                System.out.println(Thread.currentThread().getName() + " my job done");
                            } finally {
                                lock2.unlock();
                                System.out.println(Thread.currentThread().getName() + "释放lock2");
                            }
                        }
                    } finally {
                        System.out.println(Thread.currentThread().getName() + "释放lock1");
                        lock1.unlock();
                        System.out.println(Thread.currentThread().getName() + "释放lock1");
                    }
    
                }
            } else {
    
                if (lock2.tryLock()) {
                    System.out.println(Thread.currentThread().getName() + "得到lock2");
                    try {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        boolean b = lock1.tryLock();
                        System.out.println(Thread.currentThread().getName() + "lock1的申请结果：" + b);
                        if (b) {
                            try {
                                System.out.println(Thread.currentThread().getName() + " my job done");
                            } finally {
                                lock1.unlock();
                                System.out.println(Thread.currentThread().getName() + "释放lock1");
                            }
    
                        }
                    } finally {
                        System.out.println(Thread.currentThread().getName() + "释放lock2");
                        lock2.unlock();
                    }
    
                }
            }
        }
        public static void main(String[] args) {
            ReentrantLockTryLockDemo lockDemo1 = new ReentrantLockTryLockDemo(1);
            ReentrantLockTryLockDemo lockDemo2 = new ReentrantLockTryLockDemo(2);
    
            Thread thread = new Thread(lockDemo1);
            Thread thread1 = new Thread(lockDemo2);
            thread.start();
            thread1.start();
        }
    
    }
    复制代码

运行结果如下

![format_png 2][]

可以看出并没有因为没得锁资源而导致线程阻塞。如果将`trylock()`换成`lock()`则会导致线程死锁，两个线程都将阻塞在这里。

ReentrantLock的实现既具有悲观锁、重入锁、独占锁的性质、同时也实现了公平锁和非公平锁，默认是非公平锁，可通过构造函数来构造公平锁

// 构造函数
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
     public static void main(String[] args) {
         ReentrantLock lock = new ReentrantLock(true);// 指定为公平锁
     }
    
    复制代码

### ReentrantLock::newCondition ###

在`ReentrantLock`中还提供了`Condition`，他的用法和Object类中的api相似即`Object::wait(),Object::singal()`等

>  *  `await()`
>  *  `awaitUninterruptibly()`
>  *  `awaitNanos(timeout)`
>  *  `awaitUntil(date deadline)`
>  *  `singal()`
>  *  `singalAll()`

上面的`await`开头方法会使当前线程释放当前锁，进入等待状态，和`Object::wait()`方法类似，而且`Condition`中的方法需要在获得`ReentrantLock`锁之后才能运行，否则会出现`java.lang.IllegalMonitorStateException`异常

public class ConditionDemo implements Runnable{
    
        public static ReentrantLock lock = new ReentrantLock();
        public static Condition condition = lock.newCondition();
    
        @Override
        public void run() {
            try {
                lock.lock();
                condition.await(); // 释放锁
                System.out.println("going on");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            ConditionDemo demo = new ConditionDemo();
            Thread thread = new Thread(demo);
            thread.start();
            Thread.sleep(2000);
            lock.lock(); // 得到锁
            condition.signal(); // 唤醒其他线程
            lock.unlock();// 释放锁
            // output: going on
        }
    }
    复制代码

## Semaphore ##

信号量：信号量为javad的线程同步提供了更强大的方法，信号量允许多个线程同时访问一个资源，类似于读锁。主要方法如下

>  *  `acquire()`：获取一个许可，响应中断
>  *  `acquire(int)`: 获取指定数目的许可
>  *  `acquireUniterruptibly()`：获取许可不响应中断
>  *  `tryAcquire()`：尝试获取一个许可，如果成功返回true否则返回false，不会进行线程阻塞
>  *  `tryAcquire(timeout,unit)`：指定时间内获取许可，成功返回true
>  *  `release()`：释放许可

需要注意的是：获取了几个许可，就要释放几个许可，这样才能保证程序的正确性，

public class SemaphoreDemo implements Runnable{
        public Semaphore semaphore = new Semaphore(5);
    
        @Override
        public void run() {
            try {
                semaphore.acquire(2);
                System.out.println("线程：" + Thread.currentThread().getName() + "得到许可");
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                System.out.println(Thread.currentThread().getName() + "释放许可");
                semaphore.release(2);
                // semaphore.release();
            }
        }
    
        public static void main(String[] args) {
            SemaphoreDemo demo = new SemaphoreDemo();
            ExecutorService service = Executors.newFixedThreadPool(10);
            for (int i = 0; i <10; i++) {
                service.submit(demo);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    复制代码

如果注释掉`semaphore.release(2);`打开其下面的注释代码，运行结果将如下图所示

![format_png 3][]

运行不会结束，也没有后续输出。这是因为这几个线程都获取了2个信号量，但是只释放了一个信号量，导致后面的线程获取不到足够的信号量来运行程序。

## ReentrantReadWriteLock ##

读写锁：把线程的操作分为读逻辑和写逻辑，读是获取值，写是修改值

>  *  读操作和读操作不会阻塞
>  *  读操作和写操作会阻塞
>  *  写操作和写操作相互阻塞

一个线程要么进行读操作，要么进行写操作，不能同时进行读写操作。会阻塞

public class ReentrantReadWriteLockDemo implements Runnable {
    
        public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        public static Lock readLock = lock.readLock();
        public static Lock writeLock = lock.writeLock();
        public static void main(String[] args) {
            ReentrantReadWriteLockDemo runnable = new ReentrantReadWriteLockDemo();
            ExecutorService service = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 10; i++) {
                service.submit(runnable);
            }
        }
        @Override
        public void run() {
            handleLock();
        }
        public void handleLock(){
            try {
                // readLock.lock();
                writeLock.lock();
                // System.out.println(Thread.currentThread().getName() + " 读readLock " + LocalDateTime.now());
                System.out.println(Thread.currentThread().getName() + " 写writeLock " + LocalDateTime.now());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            finally {
                // readLock.unlock();
                writeLock.unlock();
            }
    
        }
    }
    复制代码

注释掉writeLock，打开readLock相关代码，可以得到如下的运行结果：

![format_png 4][]

可以看到，在同一时刻，线程都得到了运行，相互之间没有阻塞。

反之得到这样的结果

![format_png 5][]

注意不能同时打开`readLock和writeLock`如果这样做，将得不到任何输出。

参考资料：

>  *  Java高并发程序设计
>  *  Java并发实战

[format_png]: https://img-blog.csdnimg.cn/img_convert/b155b8fc65fc8719b13e2a3439a8b33f.webp?x-oss-process=image/format,png
[Java]: https://juejin.cn/post/7216914115259514935
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/210c87d07bb06595412935f2c7518946.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/6f57f0f91b6cf774df72713208bab15e.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/d75f79160051476df27c2a5fe8ebb2aa.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/85f59bb4b88440d18a19012a613c7465.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/74b779d78b250469c632a6452b385105.webp?x-oss-process=image/format,png