什么是线程?
线程(Thread)是一个程序内部的一条执行流程
程序中如果只有一条执行流程,那这个程序就是单线程的程序
多线程是什么?
多线程是指从软硬件上实现的多条执行流程的技术(多线程由CPU负责调度执行)。
如何在程序中创建多条线程?
Java是通过java.lang.Thread类的对象来代表线程的。
多线程的创建方式一:集成Thread类
- 定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法
- 创建MyThread类的对象
- 调用线程对象的start() 方法启动线程(启动后还是执行run方法的)
方式一优缺点:
优点:编码简单
缺点:线程类已经继承Thread,无法继承其他类,不利于功能的扩展
多线程的注意事项
- 启动线程必须是调用start()方法,不是调用run()方法
- 不要把主线程任务放在启动子线程之前
多线程的创建方式二:实现Runable接口
- 定义一个线程任务类MyRunable实现Runable接口,重写run()方法
- 创建MyRunable任务对象
- 把MyRunable任务对象交给Thread处理
- 调用线程对象的start()方法启动线程
方式二的优缺点
优点:任务类只是实现接口,可以继续继承其他类,实现其他接口,扩展性强
缺点:需要多一个Runable对象
线程创建方式二的匿名内部类写法
- 可以创建Runable的匿名内部类对象
- 再交给Thread线程对象
- 在调用线程对象的start()启动线程
public class ThreadTest2_2 {
public static void main(String[] args) {
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程1输出====" + i);
}
}
};
new Thread(target).start();
// 简化1
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程2输出====" + i);
}
}
}).start();
// lambda简化
new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("子线程3输出====" + i);
}
}).start();
for (int i = 0; i < 5; i++) {
System.out.println("Main线程在输入====" + i);
}
}
}
前两条线程创建方式都存在一个问题
假如线程执行完毕后有一些数据需要返回,他们重写的run方法均不能直接返回结果
怎么解决这个问题?
JDK5.0提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式)。
这种方式最大的优点:可以返回线程执行完毕的结果
多线程的第三种创建方式:利用Callable接口和FutureTask类实现
1、创建任务对象
-->定义一个类实现Callable接口,重写call方法,封装要做的事情,和要返回的数据。
-->把callable类型的对象封装成FutureTask(线程任务对象)。
2、把线程任务对象交给Thread对象
3、调用Thread对象的start方法启动线程
4、线程执行完毕后,通过FutureTask对象的get方法获取线程任务执行结果
线程创建方式三的优缺点:
优点:线程任务类只是实现接口,可以继承类和实现接口,扩展性强,可以在线执行完毕后去获取线程执行的结果
缺点:编码复杂一点
public class ThreadTest3 {
public static void main(String[] args) throws Exception {
Callable<String> call = new MyCallable(100);
// 把Callable的对象封装成一个FutureTask对象(任务对象)
//任务对象,实现了Runnable对象
//可以在任务执行完毕后调用对象的get方法获取线程执行完毕的返回结果
FutureTask<String> f1 = new FutureTask<>(call);
// 任务对象封装给Thread对象
new Thread(f1).start();
// 获取线程执行完毕后的结果
// 上面线程没有执行完毕 该处会等待
String rs = f1.get();
System.out.println(rs);
// 穿插执行互不干扰
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
new Thread(f2).start();
String rs2 = f2.get();
System.out.println(rs2);
}
}
Thread提供的方法
public class ThreadTest1 {
public static void main(String[] args) {
// getName()获取线程名字
Thread t1 = new MyThread("1号线程");
// 为线程设置名称 setName()
// t1.setName("1号线程");
t1.start();
System.out.println(t1.getName());
Thread t2 = new MyThread("2号线程");
// t2.setName("2号线程");
t2.start();
System.out.println(t2.getName());
// 主线程名字
Thread a = Thread.currentThread();
a.setName("Main线程");
System.out.println(a.getName());
for (int i = 0; i < 3; i++) {
System.out.println("main线程输出:" + i);
}
}
}
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
for (int i = 0; i <= 5; i++) {
System.out.println(i);
if(i==3){
// 让当前线程休眠5秒 sleep(毫秒)
Thread.sleep(2000);
}
}
// 控制线程执行顺序 join()
Thread t1 = new MyThread("1号线程");
t1.start();
t1.join();
Thread t2 = new MyThread("2号线程");
t2.start();
Thread t3 = new MyThread("3号线程");
t3.start();
t3.join();
}
}
什么是线程安全问题?
多线程,同时操作同一个共享资源的时候,可能会出现业务安全问题
同步代码块
作用:把访问共享资源的核心代码给上锁,以此保证线程安全。
synchronized(同步锁){
访问共享资源的核心代码
}
原理:每次只允许一个线程加锁后进入,执行完毕后自动解锁,其他线程才可以进来执行。
同步锁的注意事项:
对于当前同时执行的线程来说,同步锁必须是同一把(同一个对象),否则会出bug。
锁对象随便选择一个唯一的对象好不好呢?
不好,会影响其他无关线程的执行
锁对象的使用规范
建议使用共享资源作为锁对象,对于实例方法建立使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
synchronized (this) {
if(this.money>= money){
System.out.println(name + "来取钱:" + money);
this.money -= money;
System.out.println(name + "取钱后,余额剩余:" + this.money);
} else {
System.out.println(name + "取钱失败,余额不足");
}
}
同步方法
作用:把访问共享资源的核心代码给上锁,以此保证线程安全。
修饰符 synchronized 返回值类型 方法名称(形参列表) {
操作共享资源代码;
}
原理:每次只允许一个线程加锁后进入,执行完毕后自动解锁,其他线程才可以进来执行。
同步方法底层原理
同步方法其实底层也是隐式锁对象的,只是锁的范围是整个方法代码。
如果方法时实例方法:同步方法默认用this作为的锁对象。
如果方法时静态方法:同步方法默认用类名.class作为的锁对象
同步代码块锁的范围小,相对性能好些!
public synchronized void drawMoney(double money)
Lock锁
Lock锁是JDK5开始提供的一个新的锁定操作,通过它可以创建出锁对象进行加锁和解锁,更灵活、更方便、更强大。
Lock是接口,不能直接实例化,可以采用它的实现类ReentrantLock来构建Lock锁对象。
private final Lock LK = new ReentrantLock();
public void drawMoney(double money) {
// 获取
String name = Thread.currentThread().getName();
LK.lock();
// 防止核心代码出问题 lock解锁不能执行
try {
if (this.money >= money) {
System.out.println(name + "来取钱:" + money);
this.money -= money;
System.out.println(name + "取钱后,余额剩余:" + this.money);
} else {
System.out.println(name + "取钱失败,余额不足");
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
LK.unlock();
}
}
什么是线程通信?
当多个线程共同操作共享的资源时,线程间通过某种方式相互告知自己的状态,以相互协调,并避免无效的资源争夺。
线程通信的常见模型(生产者与消费者模型)
生产者线程负责生产数据
消费者线程负责消费生产者生产的数据
注意:生产者生产完数据应该等待自己,通知消费者消费,消费者消费完数据也应该等待自己,通知生产者生产!
public class Desk {
private List<String> list = new ArrayList<>();
// 厨师1、厨师2、厨师3都要调用 防止同步线程出错 加synchronized
public synchronized void put() {
try {
String name = Thread.currentThread().getName();
if(list.size()==0){
list.add(name + "做了一个肉包子!");
System.out.println(name + "做了一个肉包子~~");
Thread.sleep(2000);
// 唤醒其他线程 自己等待
this.notify();
this.wait();
} else {
// 唤醒其他线程 自己等待
this.notify();
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 吃货1 吃货2
public synchronized void get(){
String name = Thread.currentThread().getName();
try {
if(list.size()==1){
list.remove(0);
System.out.println(name + "吃了一个肉包子");
Thread.sleep(1000);
// 唤醒其他线程 自己等待
this.notify();
this.wait();
}else {
// 唤醒其他线程 自己等待
this.notify();
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
Desk desk = new Desk();
new Thread(()->{
while (true) {
desk.put();
}
}, "厨师1").start();
new Thread(()->{
while (true) {
desk.put();
}
}, "厨师2").start();
new Thread(()->{
while (true) {
desk.put();
}
}, "厨师3").start();
new Thread(()->{
while (true) {
desk.get();
}
}, "吃货1").start();
new Thread(()->{
while (true) {
desk.get();
}
}, "吃货2").start();
}
}
线程池
是一个可以复用线程的技术
不使用线程池的问题
用户每发起一个请求,后台就需要创建一个新线程来处理,下次新任务来了肯定又要创建新线程处理的,而创建新线程的开销是很大的,并且请求过多时,肯定会产生大量的线程出来,这样会严重影响系统的性能。
谁代表线程池
JDK 5.0起提供了代表线程池的接口:Executorservice。
如何得到线程池对象?
方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线
方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象。
ThreadPoolExecutor构造器
- 参数一:corePoolSize:指定线程池的核心线程的数量。
- 参数二:maximumPoolSize:指定线程池的最大线程数量。
- 参数三:keepAliveTime:指定临时线程的存活时间。
- 参数四:unit:指定临时线程存活的时间单位(秒、分、时、天)
- 参数五:workQueue:指定线程池的任务队列。
- 参数六:threadFactory:指定线程池的线程工厂
- 参数七:handler:指定线程池的任务拒绝策略(线程都在忙,任务队列也满了的时候,新任务来了该怎么处理)
线程池的注意事项
1、临时线程什么时候创建?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程。
2、什么时候会开始拒绝新任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始拒绝任务。
新任务拒绝策略
策略 详解
ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy 丢弃任务,但是不抛出异常 这是不推荐的做法ThreadPoolExecutor.Discard0ldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用任务的run()方法从而绕过线程池直接执行
Executors
是一个线程池的工具类,提供了很多静态方法用于返回不同特点的线程池对象。
方法名称 | 说明 |
newFixedThreadPool(int nThreads) | 创建固定线程数量的线程池,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程替代它。 |
newSingleThreadExecutor() | 创建只有一个线程的线程池对象,如果该线程出现异常而结束,那么线程池会补充一个新线程。 |
newCachedThreadPool() | 线程数量随着任务增加而增加,如果线程任务执行完毕且空闲了60s则会被回收掉。 |
newScheduledThreadPool(int corePoolsize) | 创建一个线程池,可以实现在给定的延迟后运行任务或者定期执行任务。 |
注意:这些方法的底层,都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险
进程
- 正在运行的程序(软件)就是一个独立的进程
- 线程是属于进程的,一个进程中可以同时运行很多个线程
- 进程中的多个线程其实是并发和并行执行的
并发含义
进程中的线程是由CPU负责调度执行的,但CPU能同时处理线程的数量有限,为了保证全部线程都能往前执行,CPU会轮询为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发。
并行的理解
在同一时刻上,同时有多个线程在被CPU调度执行
线程的生命周期
- 也就是线程从生到死的过程中,经历的各种状态及状态转换。
- 理解线程这些状态有利于提升并发编程的理解能力。
Java线程的6种状态
Thread.State()
线程的6种状态总结
线程状态 | 说明 |
NEW(新建) | 线程刚被创建,但是并未启动。 |
Runnable(可运行) | 线程已经调用了start(),等待CPU调度 |
Blocked(锁阻塞) | 线程在执行的时候未竞争到锁对象,则该线程进入Blocked状态;。 |
Waiting(无限等待) | 一个线程进入Waiting状态,另一个线程调用notify或者notifyA11方法才能够唤醒 |
Timed Waiting(计时等待) | 同waiting状态,有几个方法(sleep,wait)有超时参数,调用他们将进入Timed Waiting状态 |
Teminated(被终止) | 因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡。 |