ReentrantLock(可重入锁) Semaphore(信号量) CountDownLatch

ReentrantLock(可重入锁) &Semaphore(信号量)&CountDownLatch

ReentrantLock(可重入锁)

上古时期的Java中，synchronized不够强壮，功能也不够强大，也没有各种优化

ReentrantLock就是用来实现可重入锁的选择（历史遗留）

后来synchronized变得厉害了，ReentrantLock用的少了，但是仍有一席之地

synchronized也是可重入锁

传统的锁的风格，这个对象提供了两个方法： lock unlock 这个写法，就容易引起，加了锁之后，忘记解锁了

在unlock之前，触发了return或者异常，就可能引起unlock执行不到了

正确使用ReentrantLock就需要把unlock操作放到finally中

既然有了synchronized，为啥还要有ReentrantLock?

1.ReentrantLock提供了tryLock操作

lock直接进行加锁，如果加锁不成，就要阻塞

tryLock尝试进行加锁，如果加锁不成，不阻塞，直接返回false

此处通过tryLock提供了更多的“可操作空间”

2.ReentrantLock提供了公平锁的实现

ReentrantLock提供了公平锁的实现，通过队列记录加锁线程的先后顺序

synchronized是非公平锁

遵循先来后到，就是公平

3.搭配的等待通知机制不同

对于synchronized，搭配wait/notify

对于ReentrantLock，搭配 Condition类，功能比 wait/notify略强一点

实际上绝大部分开发中，使用synchronized就够用了

Semaphore(信号量)

信号量是由迪杰斯特拉提出来的

信号量也是操作系统内部给咱们提供的一个机制

操作系统对应的API被JVM封装了下，就可以通过Java代码来调用这里的相关操作了

所谓的锁，本质上也是一种特殊的信号量，

锁，可以认为就是计数值为1的信号量

释放状态，就是1

加锁状态，就是0

对于这种非0即1的信号量，称为“二元信号量”

信号量是更广义的锁

public class ThreadDemo37 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore=new Semaphore(1);
        semaphore.acquire();
        System.out.println("申请1");
        semaphore.acquire();
        System.out.println("申请2");
        semaphore.acquire();
        System.out.println("申请3");
    }
}

import java.util.concurrent.Semaphore;


public class ThreadDemo38 {
    public static  int count=0;
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore=new Semaphore(1);
        Thread t1=new Thread(()->{
           for(int i=0;i<500;i++){
               try {
                   semaphore.acquire();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               count++;
               semaphore.release();

           }
        });
        Thread t2=new Thread(()->{
            for(int i=0;i<500;i++){
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                count++;
                semaphore.release();

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

如何确保线程安全呢？

1.synchronized

2.ReentrantLock

3.CAS（原子类）

4.Semaphore

semaphore也可以用来实现生产者消费者模型

定义两个信号量

一个用来表示，队列中有多少个可以被消费的元素，sem1

另一个用来表示队列中有多少个可以放置新元素的空间 ，sem2

生产一个元素，sem1.V() , sem2.P()

消费一个元素，sem1.P() , sem2.V()

CountDownLatch

针对特定场景解决问题的小工具！

比如，多线程执行一个任务，把大的任务拆分成几个部分，由每个线程分别执行

下载一个文件，可能很大，但是可以拆成多个部分，每个线程负责下载一部分，下载完成之和，最终把下载的结果拼在一起。

像多线程下载这样的场景，最终执行完成之后，要把所有内容拼在一起

这个拼必然要等到所有线程执行完成

使用CountDownLatch就可以很方便的感知到这个事情！（比你调用很多次join要更简单方便一些）

如果使用join方式，就只能使用每个线程执行一个任务

借助CountDownLatch就可以让一个线程能执行很多个任务

import java.util.Random;
import java.util.concurrent.CountDownLatch;


public class ThreadDemo39 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch=new CountDownLatch(10);
        for(int i=0;i<10;i++){
            int id=i;
            Thread t=new Thread(()->{
                System.out.println("任务："+id+",开始下载");
                Random random = new Random();
                // [0, 5)
                int time = (random.nextInt(5) + 1) * 1000;
                try {
                    Thread.sleep(time);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("任务："+id+",结束下载");
                latch.countDown();

            }) ;
            t.start();
        }
        latch.await();
        System.out.println("所有下载完毕");
    }
}