多线程—JUC（java.util.concurrent）

上篇文章：

多线程—synchronized原理https://blog.csdn.net/sniper_fandc/article/details/146713129?fromshare=blogdetail&sharetype=blogdetail&sharerId=146713129&sharerefer=PC&sharesource=sniper_fandc&sharefrom=from_link

目录

1 Callable接口

2 ReentrantLock

3 原子类

4 线程池

5 信号量Semaphore

6 CountDownLatch

---

1 Callable接口

        在多线程环境下，如果要计算1+...+100的值，没有学习Callable接口前，可能我们写的代码如下：

public class CallThread {public static Object locker = new Object();public static int sum = 0;public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {int result = 0;for(int i = 1;i <= 100;i++){result += i;}synchronized (locker){sum = result;locker.notify();}});t.start();synchronized (locker){while(sum == 0){locker.wait();}System.out.println("1+...+100 = " + sum);}}}

        由于run方法没有返回值，因此必须使用全局变量sum来接收计算结果，同时要输出计算结果，必须得等线程运行结束，因此使用wait和notify方法来保证线程同步。这样的代码是比较繁琐的，如果使用了Callable接口，就会简化很多：

public class CallThread {public static void main(String[] args) throws InterruptedException, ExecutionException {Callable<Integer> callable = new Callable<Integer>() {public Integer call() throws Exception {int result = 0;for(int i = 1;i <= 100;i++){result += i;}return result;}};FutureTask<Integer> futureTask = new FutureTask<>(callable);Thread t = new Thread(futureTask);t.start();System.out.println("1+...+100 = " + futureTask.get());}}

        上述代码的运行结果如下：

        Callable接口类似Runnable接口，也是定义线程需要执行的任务，但是不同的是这个任务可以带返回值，返回值类型就是泛型参数类型。定义任务后，需要用FutureTask来包装这个任务，用于接收Callable实例的返回值。创建线程需要把FutureTask的实例作为参数传入，线程执行结束后，会把计算结果放入FutureTask的实例中。获取FutureTask实例中的返回值需要用到get()，如果线程还没有执行结束，代码会阻塞到get()方法的位置，直到线程执行结束接收到返回值。

2 ReentrantLock

        ReentrantLock直译可重入锁，和synchronized类似，也是通过加锁实现共享数据的互斥访问。

        ReentrantLock类加锁操作的实现方式是通过ReentrantLock的实例.lock()来加锁，通过ReentrantLock的实例.unlock()来解锁：

ReentrantLock lock = new ReentrantLock();lock.lock();... lock.unlock();   

         但是这种方式往往给开发人员带来更复杂的代码逻辑，导致如果加锁过程中出现异常，可能程序就执行不到解锁，因此常常搭配try-catch-finally语句使用：

ReentrantLock lock = new ReentrantLock();lock.lock();  try {    ...} finally {    lock.unlock()    }

        有了synchronized，为什么还需要ReentrantLock？（它们的区别是什么）

        1.synchronized是关键字，是JVM内部的实现。而ReentrantLock是一个类，是标准库的一个类，是基于java的实现。

        2.synchronized的加锁解锁基于代码块，进入代码块加锁，退出代码块解锁，不需要显示调用加锁解锁的代码。ReentrantLock的加锁解锁基于lock()和unlock()，需要显示调用方法，更灵活，但是解锁容易遗漏。

        3.synchronized是非公平锁。而ReentrantLock默认是非公平锁，但是也提供了公平锁版本，构造方法传参true就会启用公平锁策略。

        4.synchronized如果加锁失败，就会进入阻塞状态。而ReentrantLock提供trylock()方法，这个方法会尝试加锁，如果加锁失败，不会进入阻塞状态并返回false，继续向下执行其他代码。trylock()还可以设置一定的等待时间，如果加锁失败，就等待一会，时间一过再放弃。

     5.synchronized必须使用wait()和notify()来等待和唤醒，唤醒时随机唤醒一个线程。ReentrantLock搭配Condition类实现等待和唤醒，可以随机唤醒一个，也可以唤醒指定线程。

        当锁竞争不激烈时，使用synchronized更好（偏向锁和轻量级锁）。当锁竞争激烈时，使用ReentrantLock更灵活，不让线程死等。如果想要使用公平锁，也要用ReentrantLock。

3 原子类

        原子类基于CAS实现，因此比加锁实现的代码性能更高，主要有以下几个类：AtomicBoolean、AtomicInteger、AtomicIntegerArray、AtomicLong、AtomicReference、AtomicStampedReference。

        常见的方法有：addAndGet(int delta)<=>i += delta、decrementAndGet()<=>--i、getAndDecrement()<=>i--、incrementAndGet()<=>++i、getAndIncrement()<=>i++，这些方法都是AtomicInteger类中的方法。

4 线程池

        线程池的创建最核心的类是ThreadPoolExecutor类，这个类有多种参数，帮助我们创建多种类型的线程池：

        corePoolSize：核心线程的数量。（核心线程一旦创建就一直存在）

        maximumPoolSize：最大线程的数量=核心线程+临时线程的数目。(临时线程：一段时间不干活，就被销毁)

        keepAliveTime：临时线程允许的空闲时间。

        unit：keepaliveTime的时间单位，是秒，分钟等等。

        workQueue：传递任务的阻塞队列。线程池内部有默认的阻塞队列，我们也可以传入自定义的队列。（线程池的可扩展性）

        threadFactory：创建线程的工厂，参与具体的创建线程工作。

        RejectedExecutionHandler：拒绝策略，如果任务量超出线程池的任务队列的负荷了接下来怎么处理。策略有如下四种：

        AbortPolicy()：超过负荷，直接抛出异常。

        CallerRunsPolicy()：调用者负责处理。

        DiscardOldestPolicy()：丢弃队列中最老的任务。

        DiscardPolicy()：丢弃新来的任务。

        而前面使用线程池创建线程方法中使用的Executors本质上是ThreadPoolExecutor类的封装。

        注意：创建线程池时线程数量如何设置？但凡回答具体的数字都是错的，正确的做法是根据不同的程序设置不同数量，可以通过压测（性能测试）来控制不同线程数量，观察CPU占用率、内存占用率等等来确定合适的线程数量。

5 信号量Semaphore

        信号量Semaphore表示可用资源的数量，本质上是一个计数器，在信号量机制中有操作P和V（都是原子性的操作），P操作表示申请资源，因此P操作后资源数量-1；V操作表示释放资源，V操作后资源数量+1。当可用资源数量为0时，P操作阻塞，因此通过信号量机制也可以实现线程同步。

        P操作对应的方法是acquire()，V操作对应的方法是release()。具体使用如下：

public class MySemaphore {public static void main(String[] args) throws InterruptedException {Semaphore semaphore = new Semaphore(3);semaphore.acquire();System.out.println("获取资源");semaphore.acquire();System.out.println("获取资源");semaphore.acquire();System.out.println("获取资源");//        semaphore.release();//        System.out.println("释放资源");semaphore.acquire();System.out.println("获取资源");}}

        创建包含3个资源的计数器，但是main尝试连续获取4个资源，结果是被阻塞到第4次acquire()处。

        如果把代码中的注释取消，即连续3次获取资源，此时可用资源的数量为0，再释放一次资源，此时可用资源的数量为1，再获取1次资源即可顺利执行。

6 CountDownLatch

        CountDownLatch这个类会等待所有的任务都执行结束后再执行后续的代码，具体使用如下：

public class CountDownLatchDemo {public static void main(String[] args) throws InterruptedException {CountDownLatch countDownLatch = new CountDownLatch(10);for(int i = 0;i < 10;i++){Thread t = new Thread(() ->{try {//Math.random()返回0-1之间的随机数Thread.sleep((long)(Math.random() * 5000));System.out.println(Thread.currentThread().getName() + "执行完毕了");countDownLatch.countDown();} catch (InterruptedException e) {e.printStackTrace();}},"线程"+ i);t.start();}countDownLatch.await();System.out.println("所有任务都执行完了,工作结束");}}

        CountDownLatch的构造方法传入的参数表示任务的个数，对应内部有个计数器，每当一个任务调用countDownLatch.countDown()，计数器-1。await()会进行阻塞，直到计数器为0。只有所有任务都调用countDown()，计数器为0，所有任务都执行完毕，此时await()方法才结束阻塞。代码运行结果如下：

下篇文章：