1 多线程入门
1.1 多线程相关的概念
- 并发与并行
- 并行:在同一时刻,有多个任务在多个CPU上同时执行。
- 并发:在同一时刻,有多个任务在单个CPU上交替执行。
- 进程与线程
- 进程:就是操作系统中正在运行的一个应用程序。
- 线程:就是应用程序中做的事情。比如:360软件中的杀毒,扫描木马,清理垃圾。程序运行的基本执行单元,一个程序在执行时会,会在系统中建立一个进程,该进程至少建立一个线程(该线程成为主线程)作为这个程序的入口点。
1.2 什么是多线程
- 是指从软件或者硬件上实现多个线程并发执行的技术。
具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程,提升性能。 - 好处 : 提高任务的执行性能
1.3 多线程的创建方式
1 继承Thread类
- 优点:代码实现比较简单,可以直接使用Thread类中功能
- 缺点:扩展性比较差,只能继承Thread类,执行任务完毕没有返回值结果,有异常只能捕获
2 实现Runable接口
- 优点:代码实现比较简单,扩展性比较强,因为可以继承其他类
- 缺点:不能直接使用Thread类中的功能,任务执行完毕之后没有返回值结果,有异常只能捕获
3 实现Callable接口
- 优点:扩展性强可以集成其它类,任务执行完毕之后会有一个返回值结果,如果任务中出现了异常可以抛也可以被捕获
- 实现比较复杂,不能直接使用Thread类中的功能
4
1.3.1 继承Thread方式
-
基本步骤:
- 创建一个类继承Thread类。
- 在类中重写run方法(线程执行的任务放在这里)
- 创建线程对象,调用线程的start方法开启线程。
- 执行程序,观察控制台的打印数据的现象
package com.itheima.thread_demo; /* 线程的创建方式1:继承Thread方式 基本步骤 : 1 创建一个类继承Thread类。 2 在类中重写run方法(线程执行的任务放在这里) 3 创建线程对象,调用线程的start方法开启线程。 需求 : 我们启动一个Java程序,其实默认就存在一个主线程(main方法所在线程) 接下来,我们在主线程启动一个线程,打印1到100的数字,主线程启动完线程后又打印1到100的数字。 此时主线程和启动的线程在并发执行,观察控制台打印的结果。 */ public class MyThread01 { public static void main(String[] args) { // 创建线程对象,调用线程的start方法开启线程。 MyThread mt = new MyThread(); mt.start(); // main方法中的任务 for (int i = 1; i <= 100; i++) { System.out.println("i:" + i); } } } // 创建一个类继承Thread类。 class MyThread extends Thread { // 在类中重写run方法(线程执行的任务放在这里) @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println("i:" + i); } } }
1.3.2 实现Runable方式
-
构造方法
- public Thread(Runnable target)
- public Thread(Runnalbe target , String name)
-
实现步骤
- 定义任务类实现Runnable,并重写run方法
- 创建任务对象
- 使用含有Runnable参数的构造方法,创建线程对象并指定任务。
- 调用线程的start方法,开启线程
package com.itheima.thread_demo; /* 线程的创建方式2:实现Runnable方式 基本步骤 : 1 定义任务类实现Runnable,并重写run方法 2 创建任务对象 3 使用含有Runnable参数的构造方法,创建线程对象并指定任务。 4 调用线程的start方法,开启线程 需求 : 我们启动一个Java程序,其实默认就存在一个主线程(main方法所在线程) 接下来,我们在主线程启动一个线程,打印1到100的数字,主线程启动完线程后又打印1到100的数字。 此时主线程和启动的线程在并发执行,观察控制台打印的结果。 */ public class MyThread02 { public static void main(String[] args) { // 创建线程对象,调用线程的start方法开启线程。 MyRunnable mr = new MyRunnable(); Thread thread= new Thread(mr); thread.start(); // main方法中的任务 for (int i = 1; i <= 100; i++) { System.out.println("i:" + i); } } } // 1 定义任务类实现Runnable,并重写run方法 class MyRunnable implements Runnable { // 在类中重写run方法(线程执行的任务放在这里) @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println("i:" + i); } } }
1.3.3实现Callable接口
1.创建一个实现Callable的实现类
2.实现call方法,将此线程需要执行的操作声明在call方法中
3.创建Callable接口的实现类的对象
4.将Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
6.获取Callable中call方法的返回值
- 相比run()方法,可以有返回值,返回的是线程执行完毕之后的结果。返回值类型可以通过接口泛型定义
- 方法可以抛出异常,被外面操作捕获,获取异常的信息
- 支持泛型的返回值
- 需要借助FutureTask类,比如获取返回结果
FutureTask
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
- call()可以有返回值
- call()可以抛出异常,被外面的操作捕获,获取异常的信息
- call()是支持泛型的
1.3.4使用线程池
**背景:**经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
**思路:**提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
-
提高响应速度(减少了创建新线程的时间)
-
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
-
便于线程管理
-
corePoolSize:核心池的大小
-
maximumPoolSize:最大线程数
-
keepAliveTime:线程没有任务时最多保持多长时间后会终止
-
线程池相关API
JDK 5.0起提供了线程池相关API:ExecutorService 和 Executors
-
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
-
void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执行Runnable
-
Future submit(Callable task):执行任务,有返回值,一般用来执行Callable
-
void shutdown() :关闭连接池
-
-
Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() :创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
1.4 Thread类中常用方法
常用方法
-
String getName():返回此线程的名称
-
Thread类中设置线程的名字
- void setName(String name):将此线程的名称更改为等于参数 name
- 通过构造方法也可以设置线程名称
-
public
static
Thread currentThread():返回对当前正在执行的线程对象的引用 -
public
static
void sleep(long time):让线程休眠指定的时间,单位为毫秒;1s=100ms -
public void join():具备阻塞作用,等待这个线程死亡,才会执行其他线程
-
static void yield():线程让步
-
暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程
-
若队列中没有同优先级的线程,忽略此方法
join() **:**当某个程序执行流中调用其他线程的 join() 方法时,调用线程将被阻塞,直到 join() 方法加入的 join 线程执行完为止
- 低优先级的线程也可以获得执行
static void sleep(long millis):(指定时间:毫秒)
-
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
-
抛出InterruptedException异常
stop(): 强制线程生命期结束,不推荐使用
boolean isAlive():返回boolean,判断线程是否还活着
-
-
线程有两种调度模型
- 分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程 - 获取的 CPU 时间片相对多一些
package com.itheima.thread_demo.thread_method; /* 线程有两种调度模型 1 分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片 2 抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程 获取的 CPU 时间片相对多一些 注意 : Java使用的是抢占式调度模型 优先级高 , 只是抢夺到cpu执行的概率高而已 , 只是一种概率问题 */ public class PriorityDemo { public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName() + ":" + i); } } }); // 优先级最低 thread1.setPriority(1); thread1.start(); Thread thread2 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName() + ":" + i); } } }); // 优先级最高 thread2.setPriority(10); thread2.start(); } }
- 分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
线程调度方法
线程有两种调度模型
- 分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
- 抢占式调度模型:让优先级高的线程优先使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取CPU时间片相对多一点
java的调度方法
- 同优先级组成先进先出队列(先到先服务),使用时间片策略
- 对高优先级,使用优先调度的抢占策略
线程的优先级,线程的优先级等级
- MAX_PRIORITY:10
- MIN_PRIORITY:1
- NORM_PRIORITY:5
涉及的方法:
- public final int getPriority():返回线程优先值
- public final void setPriority(int newPriority):改变线程的优先级,优先级范围[1,10]低到高,默认是5
说明
- 线程创建时继承父线程的优先级
- 优先级只是获得调度的概率,并非一定是高优先级线程才被调用
2 线程安全
2.1 线程安全产生的原因
- 多个线程在对共享数据进行读改写的时候,可能导致的数据错乱就是线程的安全问题了
package com.itheima.ticket_demo;
/*
电影院
*/
public class Ticket implements Runnable {
private int ticketCount = 100; // 一共有一百张票
@Override
public void run() {
while (true) {
// 如果票的数量为0 , 那么停止买票
if (ticketCount == 0) {
break;
} else {
// 有剩余的票 , 开始卖票
ticketCount--;
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
}
}
}
}
package com.itheima.ticket_demo;
/*
1 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;
2 在Ticket类中重写run()方法实现卖票,代码步骤如下
A:判断票数大于0,就卖票,并告知是哪个窗口卖的
B:票数要减1
C:卖光之后,线程停止
3 定义一个测试类TicketDemo,里面有main方法,代码步骤如下
A:创建Ticket类的对象
B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
C:启动线程
*/
public class TicketDemo {
public static void main(String[] args) {
// 创建任务类对象
Ticket ticket = new Ticket();
// 创建三个线程类对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
// 给三个线程命名
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
// 开启三个线程
t1.start();
t2.start();
t3.start();
}
}
注意 : 以上代码是有问题 , 接下来继续改进
- 因为出票是有时间的 , 所有现在在每次买票之前, 休眠100毫秒 , 尝试执行代码
package com.itheima.ticket_demo;
/*
电影院
*/
public class Ticket implements Runnable {
private int ticketCount = 100; // 一共有一百张票
@Override
public void run() {
while (true) {
// 如果票的数量为0 , 那么停止买票
if (ticketCount <= 0) {
break;
} else {
// 模拟出票的时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 有剩余的票 , 开始卖票
ticketCount--;
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
}
}
}
}
package com.itheima.ticket_demo;
/*
1 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;
2 在Ticket类中重写run()方法实现卖票,代码步骤如下
A:判断票数大于0,就卖票,并告知是哪个窗口卖的
B:票数要减1
C:卖光之后,线程停止
3 定义一个测试类TicketDemo,里面有main方法,代码步骤如下
A:创建Ticket类的对象
B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
C:启动线程
*/
public class TicketDemo {
public static void main(String[] args) {
// 创建任务类对象
Ticket ticket = new Ticket();
// 创建三个线程类对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
// 给三个线程命名
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
// 开启三个线程
t1.start();
t2.start();
t3.start();
}
}
-
通过上述代码的执行结果 , 发现了出现了负号票 , 和相同的票 , 数据有问题
- 问题出现的原因 : 多个线程在对共享数据进行读改写的时候,可能导致的数据错乱就是线程的安全问题了
2.2 线程的同步
-
概述 : java允许多线程并发执行,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用,从而保证该变量的唯一性和准确性
-
分类
- 同步代码块
- 同步方法
- 锁机制。Lock
2.3 同步代码块
同步代码块 : 锁住多条语句操作共享数据,可以使用同步代码块实现
第一部分 : 格式
synchronized(同步监视器) {
//多个线程使用的要是同一把锁,同一同步监视器
//多条语句操作共享数据的代码
}
第二部分 : 注意
1 默认情况锁是打开的,只要有一个线程进去执行代码了,锁就会关闭
2 当线程执行完出来了,锁才会自动打开
第三部分 : 同步的好处和弊端
好处 : 解决了多线程的数据安全问题
弊端 : 当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
public class Ticket implements Runnable {
private int ticketCount = 100; // 一共有一百张票
@Override
public void run() {
while (true) {
synchronized (Ticket.class) {
// 如果票的数量为0 , 那么停止买票
if (ticketCount <= 0) {
break;
} else {
// 模拟出票的时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 有剩余的票 , 开始卖票
ticketCount--;
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
}
}
}
}
}
package com.itheima.synchronized_demo1;
/*
1 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;
2 在Ticket类中重写run()方法实现卖票,代码步骤如下
A:判断票数大于0,就卖票,并告知是哪个窗口卖的
B:票数要减1
C:卖光之后,线程停止
3 定义一个测试类TicketDemo,里面有main方法,代码步骤如下
A:创建Ticket类的对象
B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
C:启动线程
*/
public class TicketDemo {
public static void main(String[] args) {
// 创建任务类对象
Ticket ticket = new Ticket();
// 创建三个线程类对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
// 给三个线程命名
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
// 开启三个线程
t1.start();
t2.start();
t3.start();
}
}
2.4 同步方法
同步方法:就是把synchronized关键字加到方法上
格式:修饰符 synchronized 返回值类型 方法名(方法参数) { }
同步代码块和同步方法的区别:
1. 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
2. 同步代码块可以指定锁对象,同步方法不能指定锁对象
注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
- 对于非static方法,同步锁就是this。
- 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象
package com.itheima.synchronized_demo2;
/*
同步方法:就是把synchronized关键字加到方法上
格式:修饰符 synchronized 返回值类型 方法名(方法参数) { }
同步代码块和同步方法的区别:
1 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
2 同步代码块可以指定锁对象,同步方法不能指定锁对象
注意 : 同步方法时不能指定锁对象的 , 但是有默认存在的锁对象的。
1 对于非static方法,同步锁就是this。
2 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。 Class类型的对象
*/
public class Ticket implements Runnable {
private int ticketCount = 100; // 一共有一百张票
@Override
public void run() {
while (true) {
if (method()) {
break;
}
}
}
private synchronized boolean method() {
// 如果票的数量为0 , 那么停止买票
if (ticketCount <= 0) {
return true;
} else {
// 模拟出票的时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 有剩余的票 , 开始卖票
ticketCount--;
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
return false;
}
}
}
package com.itheima.synchronized_demo2;
/*
1 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;
2 在Ticket类中重写run()方法实现卖票,代码步骤如下
A:判断票数大于0,就卖票,并告知是哪个窗口卖的
B:票数要减1
C:卖光之后,线程停止
3 定义一个测试类TicketDemo,里面有main方法,代码步骤如下
A:创建Ticket类的对象
B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
C:启动线程
*/
public class TicketDemo {
public static void main(String[] args) {
// 创建任务类对象
Ticket ticket = new Ticket();
// 创建三个线程类对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
// 给三个线程命名
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
// 开启三个线程
t1.start();
t2.start();
t3.start();
}
}
2.5 Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
Lock中提供了获得锁和释放锁的方法
void lock():获得锁
void unlock():释放锁
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法
ReentrantLock():创建一个ReentrantLock的实例
注意:多个线程使用相同的Lock锁对象,需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
package com.itheima.synchronized_demo3;
import java.util.concurrent.locks.ReentrantLock;
/*
虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock
Lock中提供了获得锁和释放锁的方法
void lock():获得锁
void unlock():释放锁
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法
ReentrantLock():创建一个ReentrantLock的实例
注意:多个线程使用相同的Lock锁对象,需要多线程操作数据的代码放在lock()和unLock()方法之间。一定要确保unlock最后能够调用
*/
public class Ticket implements Runnable {
private int ticketCount = 100; // 一共有一百张票
ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();// 加锁
// 如果票的数量为0 , 那么停止买票
if (ticketCount <= 0) {
break;
} else {
// 模拟出票的时间
Thread.sleep(100);
// 有剩余的票 , 开始卖票
ticketCount--;
System.out.println(Thread.currentThread().getName() + "卖出一张票,剩下" + ticketCount + "张");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();// 释放锁
}
}
}
}
package com.itheima.synchronized_demo3;
/*
1 定义一个类Ticket实现Runnable接口,里面定义一个成员变量:private int ticketCount = 100;
2 在Ticket类中重写run()方法实现卖票,代码步骤如下
A:判断票数大于0,就卖票,并告知是哪个窗口卖的
B:票数要减1
C:卖光之后,线程停止
3 定义一个测试类TicketDemo,里面有main方法,代码步骤如下
A:创建Ticket类的对象
B:创建三个Thread类的对象,把Ticket对象作为构造方法的参数,并给出对应的窗口名称
C:启动线程
*/
public class TicketDemo {
public static void main(String[] args) {
// 创建任务类对象
Ticket ticket = new Ticket();
// 创建三个线程类对象
Thread t1 = new Thread(ticket);
Thread t2 = new Thread(ticket);
Thread t3 = new Thread(ticket);
// 给三个线程命名
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
// 开启三个线程
t1.start();
t2.start();
t3.start();
}
}
3 线程死锁
3.1 概述
- 死锁是一种少见的,而且难于调试的错误,在两个线程对两个同步锁对象具有循环依赖时,就会大概率的出现死锁。我们要避免死锁的产生。否则一旦死锁,除了重启没有其他办法的
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
3.2 产生条件
- 多个线程
- 存在锁对象的循环依赖
3.3 代码实践
package com.itheima.deadlock_demo;
/*
死锁 :
死锁是一种少见的,而且难于调试的错误,在两个线程对两个同步锁对象具有循环依赖时,就会大概率的出现死锁。
我们要避免死锁的产生。否则一旦死锁,除了重启没有其他办法的
*/
public class DeadLockDemo {
public static void main(String[] args) {
String 筷子A = "筷子A";
String 筷子B = "筷子B";
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (筷子A) {
System.out.println("小白拿到了筷子A ,等待筷子B....");
synchronized (筷子B) {
System.out.println("小白拿到了筷子A和筷子B , 开吃!!!!!");
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "小白").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (筷子B) {
System.out.println("小黑拿到了筷子B ,等待筷子A....");
synchronized (筷子A) {
System.out.println("小黑拿到了筷子B和筷子A , 开吃!!!!!");
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "小黑").start();
}
}
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
4 线程的状态
5 线程通信
-
线程间的通讯技术就是
通过等待和唤醒机制
,来实现多个线程协同操作完成某一项任务
,例如经典的生产者和消费者案例。等待唤醒机制
其实就是让线程进入等待状态或者让线程从等待状态中唤醒,需要用到两种方法(都在Object类中,通过锁对象调用),如下: -
等待方法 :
- void wait() 让线程进入无限等待。
- void wait(long timeout) 让线程进入计时等待 ;在计时等待内也可以唤醒
- 以上两个方法调用会
导致当前线程释放掉锁资源
。
-
唤醒方法 :
- void notify() 随机唤醒在此对象监视器(锁对象)上等待的单个线程。
- void notifyAll() 唤醒在此对象监视器上等待的所有线程。
- 以上两个方法调用
不会导致当前线程释放掉锁资源
-
注意
- 等待和唤醒的方法,都要使用锁对象调用(需要在同步代码块中调用)
- 等待和唤醒方法应该使用相同的锁对象调用
-
package com.itheima.waitnotify_demo; /* 1 线程进入无限等待 注意:进入无限等待需要使用锁在同步代码中调用wait方法 */ public class Test1 { public static void main(String[] args) { Object obj = new Object(); // 作为锁对象 new Thread(new Runnable() { @Override public void run() { synchronized (obj) { System.out.println("线程开始执行"); System.out.println("线程进入无线等待...."); try { obj.wait(); // 进入无线等待状态 , 并释放锁 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("无线等待被唤醒...."); } } }).start(); } }
-
package com.itheima.waitnotify_demo; /* 线程进入无限等待后被唤醒 注意:等待和唤醒是两个或多个线程之间实现的。进入无限等待的线程是不会自动唤醒,只能通过其他线程来唤醒。 */ public class Test2 { public static void main(String[] args) { Object obj = new Object(); // 作为锁对象 new Thread(new Runnable() { @Override public void run() { synchronized (obj) { System.out.println("线程开始执行"); System.out.println("线程进入无线等待...."); try { obj.wait(); // 进入无线等待状态 , 并释放锁 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("无线等待被唤醒...."); } } }).start(); new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (obj) { obj.notify();// 随机唤醒此监视器中等待的线程 , 不会释放锁 System.out.println("唤醒后 , 5秒钟后释放锁"); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } }// 释放锁 } }).start(); } }
-
package com.itheima.waitnotify_demo; /* 3 线程进入计时等待并唤醒 注意:进入计时等待的线程,时间结束前可以被其他线程唤醒。时间结束后会自动唤醒 */ public class Test3 { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { synchronized (Test3.class) { System.out.println("获取到锁 , 开始执行"); try { System.out.println("进入计时等待...3秒"); Test3.class.wait(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("自动唤醒."); } } }).start(); } }
-
生产者和消费者案例
package com.itheima.waitnotify_demo2;
import sun.security.krb5.internal.crypto.Des;
/*
生产者步骤:
1,判断桌子上是否有汉堡包
如果有就等待,如果没有才生产。
2,把汉堡包放在桌子上。
3,叫醒等待的消费者开吃
*/
public class Cooker implements Runnable {
@Override
public void run() {
while (true) {
synchronized (Desk.lock) {
if (Desk.count == 0) {
break;
} else {
if (Desk.flag) {
// 桌子上有食物
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
// 桌子上没有食物
System.out.println("厨师生产了一个汉堡包...");
Desk.flag = true;
Desk.lock.notify();
}
}
}
}
}
}
package com.itheima.waitnotify_demo2;
import sun.security.krb5.internal.crypto.Des;
/*
消费者步骤:
1,判断桌子上是否有汉堡包。
2,如果没有就等待。
3,如果有就开吃
4,吃完之后,桌子上的汉堡包就没有了
叫醒等待的生产者继续生产
汉堡包的总数量减一
*/
public class Foodie implements Runnable {
@Override
public void run() {
while (true) {
synchronized (Desk.lock) {
if (Desk.count == 0) {
break;
} else {
if (Desk.flag) {
// 桌子上有食物
System.out.println("吃货吃了一个汉堡包...");
Desk.count--; // 汉堡包的数量减少一个
Desk.flag = false;// 桌子上的食物被吃掉 , 值为false
Desk.lock.notify();
} else {
// 桌子上没有食物
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
package com.itheima.waitnotify_demo2;
public class Test {
public static void main(String[] args) {
new Thread(new Foodie()).start();
new Thread(new Cooker()).start();
}
}
6 线程池
6.1 线程使用存在的问题
- 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。
如果大量线程在执行,会涉及到线程间上下文的切换,会极大的消耗CPU运算资源
6.2 线程池的介绍
- 其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。
6.3 线程池使用的大致流程
- 创建线程池指定线程开启的数量
- 提交任务给线程池,线程池中的线程就会获取任务,进行处理任务。
- 线程处理完任务,不会销毁,而是返回到线程池中,等待下一个任务执行。
- 如果线程池中的所有线程都被占用,提交的任务,只能等待线程池中的线程处理完当前任
6.4 线程池的好处
- 降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提高响应速度。当任务到达时,任务可以不需要等待线程创建 , 就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存 (每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。
6.4 Java提供好的线程池
- java.util.concurrent.ExecutorService 是线程池接口类型。使用时我们不需自己实现,JDK已经帮我们实现好了
- 获取线程池我们使用工具类java.util.concurrent.Executors的静态方
- public static ExecutorService newFixedThreadPool (int num) : 指定线程池最大线程池数量获取线程池
- 线程池ExecutorService的相关方法
- Future submit(Callable task)
- Future<?> submit(Runnable task)
- 关闭线程池方法(一般不使用关闭方法,除非后期不用或者很长时间都不用,就可以关闭)
- void shutdown() 启动一次顺序关闭,执行以前提交的任务,但不接受新任务
6.5 线程池处理Runnable任务
package com.itheima.threadpool_demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
1 需求 :
使用线程池模拟游泳教练教学生游泳。
游泳馆(线程池)内有3名教练(线程)
游泳馆招收了5名学员学习游泳(任务)。
2 实现步骤:
创建线程池指定3个线程
定义学员类实现Runnable,
创建学员对象给线程池
*/
public class Test1 {
public static void main(String[] args) {
// 创建指定线程的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
// 提交任务
threadPool.submit(new Student("小花"));
threadPool.submit(new Student("小红"));
threadPool.submit(new Student("小明"));
threadPool.submit(new Student("小亮"));
threadPool.submit(new Student("小白"));
threadPool.shutdown();// 关闭线程池
}
}
class Student implements Runnable {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void run() {
String coach = Thread.currentThread().getName();
System.out.println(coach + "正在教" + name + "游泳...");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(coach + "教" + name + "游泳完毕.");
}
}
6.6 线程池处理Callable任务
package com.itheima.threadpool_demo;
import java.util.concurrent.*;
/*
需求: Callable任务处理使用步骤
1 创建线程池
2 定义Callable任务
3 创建Callable任务,提交任务给线程池
4 获取执行结果
<T> Future<T> submit(Callable<T> task) : 提交Callable任务方法
返回值类型Future的作用就是为了获取任务执行的结果。
Future是一个接口,里面存在一个get方法用来获取值
练一练:使用线程池计算 从0~n的和,并将结果返回
*/
public class Test2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建指定线程数量的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
Future<Integer> future = threadPool.submit(new CalculateTask(100));
Integer sum = future.get();
System.out.println(sum);
}
}
// 使用线程池计算 从0~n的和,并将结果返回
class CalculateTask implements Callable<Integer> {
private int num;
public CalculateTask(int num) {
this.num = num;
}
@Override
public Integer call() throws Exception {
int sum = 0;// 求和变量
for (int i = 0; i <= num; i++) {
sum += i;
}
return sum;
}
}
6.7ThreadPoolExecutor线程池类
成员变量:
int corePoolSize 核心线程数量
int maximumPoolSize 最大线程数量
long keepAliveTime 临时线程存活
TimeUnit unit 临时线程存活时间单位
BlockingQueue workQueue 阻塞队列
ThreadFactory threadFactory 创建线程的方式
RejectedExecutionHandler handler 拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
3,
10,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(20),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);
for (int i = 1; i <= 31; i++) {
threadPool.submit(new Runnable() {
@Override
public void run() {
System.out.println("执行任务");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
}