Java EE 多线程之 JUC

文章目录

[1. Callable 接口](#1. Callable 接口)
[2. ReentrantLock](#2. ReentrantLock)
[3. 信号量](#3. 信号量)
[4. CountDownLatch](#4. CountDownLatch)

JUC这里就是指（java.util.concurrent）

concurrent 就是并发的意思

这个包里的内容，主要就是一些多线程相关的组件

1. Callable 接口

Callable 也是一种创建线程的方式

适合与想让某个线程执行一个逻辑，并且返回结果的时候

相比之下，Runnable 不关注结果

这个和Runnable 方法很像

call 方法是 Callable 中的核心方法

返回值就是 Integer，期望值这个线程能够返回一个整数

java 复制代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo35 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义了任务
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 1000; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //把任务放到线程中进行执行
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();

        //此处的 get 就能获取到 callable 里面的返回结果
        //由于线程是并发执行的，执行到主线的 get 的时候，t 线程可能还没执行完
        //没执行完的话，get 就会阻塞
        System.out.println(futureTask.get());
    }
}

futureTask 在这里就是相当于让一个线程跑起来，我们来等待结果

就相当于去吃饭，扫码点单后会给你一个小票，可以凭小票取餐

点餐完成后，后厨就相当于一个线程，就开始执行了

这个过程中，我们需要等出餐

等餐好了，就可以那小票取餐

这个时候 futureTask 就相当于拿着小票换执行结果

这个时候我们创建线程的方式有增加了一种

线程创建的方式：

继承 Thread，重写 run（创建单独的类，也可以匿名内部类）
实现 Runnable，重写 run（创建单独的类，也可以匿名内部类）
实现 Callable，重写 call（创建单独的类，也可以匿名内部类）
使用 lambda 表达式
ThreadFactory 线程工厂
线程池

2. ReentrantLock

可重⼊互斥锁，和 synchronized 定位类似，都是⽤来实现互斥效果，保证线程安全

ReentrantLock 的⽤法：

• lock()：加锁，如果获取不到锁就死等

• trylock(超时时间)：加锁，如果获取不到锁，等待⼀定的时间之后就放弃加锁

• unlock()：解锁

java 复制代码

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

ReentrantLock 的优势：

ReentrantLock ，在加锁的时候，有两种方式
lock，tryLock（给了更多的可操作空间）
ReentrantLock ，提供了公平锁的实现（默认情况下是非公平锁）
ReentrantLock 提供了更强大的等待通知机制
搭配了Condition 类，实现等待通知，可以更精确控制唤醒某个指定的线程

虽然 ReentrantLock 有上述优势，但是在加锁的时候，首选还是 synchronized

但是很明显，ReentrantLock 使用更复杂，尤其容易忘记解锁

3. 信号量

信号量也是操作系统中，比较重要的概念

信号量，就是一个计数器，描述了"可用资源"的个数

举个栗子：

可以把信号量想象成是停⻋场的展⽰牌：

当前有⻋位 100 个，表⽰有 100 个可⽤资源

当有⻋开进去的时候，就相当于申请⼀个可⽤资源，可⽤⻋位就 -1 (这个称为信号量的 P 操作)

当有⻋开出来的时候，就相当于释放⼀个可⽤资源，可⽤⻋位就 +1 (这个称为信号量的 V 操作)

如果计数器的值已经为 0 了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源

英语中 P 操作用 acquire

V 操作用 release

锁，本质上就是属于一种特殊的信号量

锁就是可用资源为 1 的信号量

加锁操作，P 操作，1 变成 0

解锁操作，V 操作，0 变成 1

这其实就是二元信号量

操作刺痛，提供了信号量实现，提供了 api，JVM 封装了这样的 api，就可以在 java 代码中使用了

java 复制代码

public class ThreadDemo36 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(4);
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        semaphore.acquire();
        System.out.println("P 操作");
        //semaphore.release();
    }
}

这里第五次操作会堵塞

开发中如果遇到了需要申请资源的常见，就可以使用信号量来实现

4. CountDownLatch

CountDownLatch 主要是适用于，多个线程来完成一系列任务的时候，用来衡量任务的进程是否完成

比如把一个大的任务，拆分成多个小的任务，让这些任务并发的去执行

就可以使用 CountDownLatch 来判定说当前这些任务是否都完成了

下载一个文件，就可以使用多线程下载

在我们的生活中，很多下载工具的下载速度很慢

相比之下，有一些专业的下载工具，就可以成倍的提升（比如 IDM）

这个时候普通的下载软件，往往和资源服务器，只有一个链接，服务器往往会对于链接传输的速度有限制

而专业的软件，往往是多线程下载，每个线程都建立一个链接，此时就需要把任务进行分割

CountDownLatch 主要有两个方法：

await ，调用的时候就会阻塞，就会等待其他的线程完成任务，所有的线程都完成了任务之后，此时这个 await 才会返回，才会继续往下走
countDown ，告诉 CountDownLatch ，我当前这一个子任务已经完成

java 复制代码

public class ThreadDemo37 {
    public static void main(String[] args) throws InterruptedException {
        //10 个选手参赛，await 就会在 10次调用完 countDown 之后才能继续执行
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            int id = i;
            Thread t = new Thread(() -> {
                System.out.println("thread " + id);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //通知说当前的任务执行完毕了
                countDownLatch.countDown();
            });
            t.start();
        }
        countDownLatch.await();
        System.out.println("所有的任务都完成了");
    }
}

如果是 i < 9，这里就会进行阻塞