目录
多线程
- 线程(thread)是一个程序内部的一条执行路径，若程序中如果只有一条执行路径，那么这个程序就是单线程的程序
- 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径
1 多线程创建的三种方式
1.1 继承Thread类
- 创建流程：
- 定义一个子类比如MyThread，继承线程类java.lang.Thread，重写run()方法
- 创建MyThread类的对象
- 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
- 注意事项：
- 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行，只有调用start方法才是启动一个新的线程执行
- 若把主线程任务放在子线程之前会导致主线程一直是先跑完的，相当于是一个单线程的效果
- 优缺点：
- 优点：编码简单
- 缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展
1.2 实现Runnable接口
- 创建流程：
- 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
- 创建MyRunnable任务对象
- 把MyRunnable任务对象交给Thread处理
- 调用线程对象的start()方法启动线程
//1、定义一个线程任务类 实现Runnable接口，重写run方法（略）
//在main中2、创建一个任务对象
Runnable target = new MyRunnable();
//3、把任务对象交给Thread处理
Thread t = new Thread(target);
//4、启动线程
t.start();补充：Tread类构造器
| 构造器 | 说明 |
| public Thread(String name) | 可以为当前线程指定名称 |
| public Thread(Runnable target) | 封装Runnable对象成为线程对象 |
| public Thread(Runnable target ，String name ) | 封装Runnable对象成为线程对象，并指定线程名称 |
- 使用匿名内部类创建流程（简化的写法）：
- 可以创建Runnable的匿名内部类对象
- 交给Thread处理
- 调用线程对象的start()启动线程
//在main中1、定义一个匿名内部类实现Runnable接口，重写run方法
//2、同时创建了任务对象
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程1执行输出：" + i);
}
}
};
//3、把任务对象交给Thread处理
Thread t = new Thread(target);
//4、启动线程
t.start();终极简化：
//简化1
//匿名内部类对象直接作为Thread构造器的参数
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("子线程2执行输出：" + i);
}
}
}).start();
//简化2
//匿名内部类对象直接作为Thread构造器的参数，并通过lambda表达式简化
new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("子线程3执行输出：" + i);
}
}).start();- 优缺点:
- 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强
- 缺点：编程多一层对象包装，线程执行结果不可直接返回
1.3 实现Callable、FutureTask接口
- 得到任务对象：
- 定义类实现Callable接口，重写call方法，封装要做的事情
- 用FutureTask把Callable对象封装成线程任务对象
- 把线程任务对象交给Thread处理
- 调用Thread的start方法启动线程，执行任务
- 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果
public class ThreadDemo3 {
public static void main(String[] args) {
// 3、创建Callable任务对象
Callable<String> call = new MyCallable(100);
// 4、把Callable任务对象 交给 FutureTask 对象
// FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口），可以交给Thread了
// FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
FutureTask<String> f1 = new FutureTask<>(call);
// 5、交给线程处理
Thread t1 = new Thread(f1);
// 6、启动线程
t1.start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
Thread t2 = new Thread(f2);
t2.start();
try {
// 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
String rs1 = f1.get();
System.out.println("第一个结果：" + rs1);
} catch (Exception e) {
e.printStackTrace();
}
try {
// 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
String rs2 = f2.get();
System.out.println("第二个结果：" + rs2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
1、定义一个任务类 实现Callable接口 应该申明线程任务执行完毕后的结果的数据类型
*/
class MyCallable implements Callable<String>{
private int n;
public MyCallable(int n) {
this.n = n;
}
/**
2、重写call方法（任务方法）
*/
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
return "子线程执行的结果是：" + sum;
}
}补充：FutureTask的API
| 方法名称 | 说明 |
| public FutureTask<>(Callable call) | 把Callable对象封装成FutureTask对象。 |
| public V get() throws Exception | 获取线程执行call方法返回的结果。 |
- 优缺点：
- 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强，可以在线程执行完毕后去获取线程执行的结果
- 缺点：编码复杂一点
1.4 三种方式对比总结
| 方式 | 优点 | 缺点 |
| 继承Thread类 | 编程比较简单，可以直接使用Thread类中的方法 | 扩展性较差，不能再继承其他的类，不能返回线程执行的结果 |
| 实现Runnable接口 | 扩展性强，实现该接口的同时还可以继承其他的类。 | 编程相对复杂，不能返回线程执行的结果 |
| 实现Callable接口 | 扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果 | 编程相对复杂 |
2 Thread类常用API
| 方法名称 | 说明 |
| String getName() | 获取当前线程的名称，默认线程名称是Thread-索引 |
| void setName(String name) | 设置线程名称 |
| public static Thread currentThread()： | 返回对当前正在执行的线程对象的引用 |
| public static void sleep(long time) | 让线程休眠指定的时间，单位为毫秒。 |
| public void run() | 线程任务方法 |
| public void start() | 线程启动方法 |
3 线程安全、线程同步、线程通信
3.1 线程安全
三大问题：可见性、有序性、原子性
- 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题
- 出现的原因：
- 存在多线程并发
- 同时访问并修改了共享资源
3.2 线程同步
- 作用：解决线程安全问题，让多个线程实现先后依次访问共享资源，这样就解决了安全问题
- 线程同步的核心思想：加锁，把共享资源上唯一锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来
3.2.1 同步代码块
- 把出现线程安全问题的核心代码给上锁，每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行
- 格式：选中出现线程安全问题的核心代码，Ctrl+Alt+t，选择synchronized
synchronized(同步锁对象) {
操作共享资源的代码(核心代码)
}- 锁对象的要求（进阶）：
- 规范上：建议使用共享资源作为锁对象
- 对于实例方法建议使用this作为锁对象
- 对于静态方法建议使用字节码（类名.class）对象作为锁对象
3.2.2 同步方法
- 作用：把出现线程安全问题的核心方法给上锁，每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行
- 格式：给方法加上synchronized关键字即可
修饰符 synchronized 返回值类型 方法名称(形参列表) {
操作共享资源的代码
}- 原理：
- 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
- 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象
- 如果方法是静态方法：同步方法默认用类名.class作为的锁对象
3.2.3 Lock锁
- 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便
- Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
- Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象
- 构造器：
| 方法名称 | 说明 |
| public ReentrantLock() | 获得Lock锁的实现类对象 |
- 方法：还有很多
| 方法名称 | 说明 |
| void lock() | 获得锁 |
| void unlock() | 主动释放锁 |
3.3 线程通信（了解）
- 所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信
- 线程通信的前提：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全
- Object类的等待和唤醒方法：
| 方法名称 | 说明 |
| void wait() | 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法 |
| void notify() | 唤醒正在等待的单个线程 |
| void notifyAll() | 唤醒正在等待的所有线程 |
注意：上述方法应该使用当前同步锁对象进行调用
4 线程池
4.1 概述
- 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能
- 线程池就是一个可以复用线程的技术
4.2 线程池实现的API、参数说明
- JDK 5.0起提供了代表线程池的接口：ExecutorService
- 获取线程池对象：
- 方式一：使用ExecutorService接口的实现类ThreadPoolExecutor自创建一个线程池对象（重要）
- 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象
- ThreadPoolExecutor构造器的参数说明：
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler
)参数一：指定线程池的线程数量（核心线程）： corePoolSize 不能小于0
参数二：指定线程池可支持的最大线程数： maximumPoolSize 最大数量 >= 核心线程数量
参数三：指定临时线程的最大存活时间： keepAliveTime 不能小于0
参数四：指定存活时间的单位(秒、分、时、天)： unit 时间单位
参数五：指定任务队列： workQueue 不能为null
参数六：指定用哪个线程工厂创建线程： threadFactory 不能为null
参数七：指定线程忙，任务满的时候，新任务来了怎么办（任务拒绝策略）： handler 不能为null
- 任务拒绝策略：
| 策略 | 详解 |
| ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 |
| ThreadPoolExecutor.DiscardPolicy： | 丢弃任务，但是不抛出异常 这是不推荐的做法 |
| ThreadPoolExecutor.DiscardOldestPolicy | 抛弃队列中等待最久的任务 然后把当前任务加入队列中 |
| ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run()方法从而绕过线程池直接执行 |
4.3 线程池常见面试题
- 临时线程什么时候创建？
新任务提交时发现核心线程（正式工）都在忙，任务队列（座位）也满了，并且还可以创建临时线程（临时工），此时才会创建临时线程
- 什么时候会开始拒绝任务？
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝（handler）
4.4 线程池处理Runnable、Callable任务
4.4.1 线程池处理Runnable任务
- 处理Runnable任务时ExecutorService的常用方法：
| 方法名称 | 说明 |
| void execute(Runnable command) | 执行任务/命令，没有返回值，一般用来执行 Runnable 任务 |
| Future submit(Callable task) | 执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务 |
| void shutdown() | 等任务执行完毕后关闭线程池（建议使用） |
| List shutdownNow() | 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务（一般不用） |
4.4.2 线程池处理Callable任务
- 处理Callable任务时ExecutorService的常用方法：
| 方法名称 | 说明 |
| void execute(Runnable command) | 执行任务/命令，没有返回值，一般用来执行 Runnable 任务 |
| Future submit(Callable task) | 执行Callable任务，返回未来任务对象获取线程结果 |
| void shutdown() | 等任务执行完毕后关闭线程池 |
| List shutdownNow() | 立刻关闭，停止正在执行的任务，并返回队列中未执行的任务 |
4.5 Executors工具类实现线程池
- 获取不同类型的线程池对象：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
| 方法名称 | 说明 |
| public static ExecutorService newCachedThreadPool() | 线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。 |
| public static ExecutorService newFixedThreadPool(int nThreads) | 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。 |
| public static ExecutorService newSingleThreadExecutor () | 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。 |
| public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) | 创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。 |
- Executors使用可能存在的陷阱：大型并发系统环境中使用Executors如果不注意可能会出现系统风险
4.6 补充：定时器
- 定时器是一种控制任务延时调用，或者周期调用的技术。如：闹钟、定时邮件发送
- 实现方式一：Timer定时器
- Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入
- 可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行
public Timer() //创建Timer定时器对象
public void schedule (TimerTask task, long delay, long period) //开启一个定时器，按照计划处理TimerTask任务- 实现方式二：ScheduledExecutorService定时器
- ScheduledExecutorService是并发包，目的是为了弥补Timer的缺陷
- 内部为线程池，某个任务的执行情况不会影响其他定时任务的执行
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) //得到线程池对象
public ScheduledFuture<?> scheduleAtFixedRate(
Runnable command,
long initialDelay,
long period,
TimeUnit unit) //周期调度方法4.7 并发与并行（面试常考）
- 正在运行的程序（软件）就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的
4.7.1 并发——CPU分时轮询的执行线程
- CPU同时处理线程的数量有限，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发
4.7.2 并行——同一时刻同时执行
- 在同一个时刻上，同时有多个线程在被CPU处理并执行
4.8 线程的生命周期
- Java总共定义了6种状态，6种状态都定义在Thread类的内部枚举类中
| 线程状态 | 描述 |
| NEW(新建) | 线程刚被创建，但是并未启动。 |
| Runnable(可运行) | 线程已经调用了start()等待CPU调度。 |
| Blocked(锁阻塞) | 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态。 |
| Waiting(无限等待) | 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep 、Object.wait。 |
| Teminated(被终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
- 状态转换：
4522
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
