1. 多线程
1.1. 并发与并行
并发
- cpu在多个任务之间快速切换, 模拟多个任务在同时执行的效果，实际是分别执行。
并行
- 多个cpu同时在执行多个任务，多个任务同时执行
并发当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。这种方式我们称之为并发(Concurrent)。
并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。
1.2. 实现多线程方式一：继承Thread类
-
方法介绍
方法名 说明 void run() 在线程开启后，此方法将被调用执行 void start() 使此线程开始执行，Java虚拟机会调用run方法 -
实现步骤
- 1定义一个类继承Thread类
- 2在类中重写run()方法
- 3用这个类创建对象
- 4用对象调用start 开启线程
1.2.1. 代码演示
【注意】
直接调用run方法，虽然方法也会执行，但是并不是通过新线程启动的，而只是普通的执行一个方法。
所以不要直接调用Thread的run方法，而是应该使用start方法启动线程。
- 创建线程的类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("我唱歌" + i);
}
}
}- 测试类中使用线程
public class Demo02 {
public static void main(String[] args) {
// 1 写一个类继承Thread
//2 重写run方法
//3 用这个类创建对象
MyThread t1 = new MyThread();
//4 用对象调用start 开启线程
t1.start();
//再次创建一个线程
MyThread t2 = new MyThread();
//开启线程
t2.start();
}
}1.3. Thread中的方法
1.3.1. 构造方法：
- Thread()：空参数的构造方法。
- Thread(String name)：一个参数是字符串的构造方法，参数表示线程名字。
1.3.2. 其它方法
- String getName()：获取线程名字。
- void setName(String name)：设置线程名字。
- static Thread currentThread()：获取当前正在执行的线程对象。
- static void sleep(long millis)：线程休眠，参数是休眠的毫秒值。
1.3.3. 代码
- 实现两个子线程一个唱歌一个跳舞，主线程打篮球 如下：
1.3.3.1. Thread子类的代码
- 两个子类，一个唱歌，一个跳舞， 都写了空参 和有参构造，有参构造里可以传入一个字符串给线程命名
- 在run中，调用了getName方法获取了线程的名字
package link.xiaomo.test3;
public class SingThread extends Thread {
public SingThread() {
}
public SingThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "唱rap" + i);
}
}
}
package link.xiaomo.test3;
public class DanceThread extends Thread {
public DanceThread() {
}
public DanceThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "跳舞" + i);
}
}
}1.3.3.2. 测试代码
- 创建Thread对象的时候，传入了线程的名字 sing和dance
- 主线程for循环中打篮球，通过Thread.currentThread() 获取当前线程对象 然后getName()获取线程的名字
package link.xiaomo.test3;
public class Demo01 {
public static void main(String[] args) {
// 一个程序默认会开启一个主线程
//我们在主线程的代码中 开启的线程 称为子线程
SingThread t01 = new SingThread("唱歌线程");
DanceThread t02 = new DanceThread("跳舞线程");
t01.start();
t02.start();
//想获取一个线程的名字 但是又不在线程内部
//Thread.currentThread() 可以获取当前的线程对象
//通过Thread.currentThread().getName()可以获取当前线程的名字了
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "打篮球" + i);
}
}
}
1.3.3.3. 线程流程图
1.4. 实现多线程方式二：实现Runnable接口
- 把任务和Thread解耦合,通过Runnable接口实现
1.4.1. Thread构造方法
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 分配一个新的Thread对象 |
| Thread(Runnable target, String name) | 分配一个新的Thread对象 |
1.4.2. 实现步骤
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数传入
- 调用Thread类的对象的start方法启动线程
1.4.3. 实现代码
- 类MyRunnable实现Runnable接口,重写run()方法,
- 方法中Thread.currentThread().getName()获取了线程的名字
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("吃肉夹馍" + i);
System.out.println(Thread.currentThread().getName());
}
}
}1.4.4. 测试代码
- 创建了三个线程
- 1 Thread t 在创建的时候，构造方法中传入了Runnable对象
- 2Thread t2，创建的时候使用lambda表达式传入了Runnable的实现类对象
- 3 直接在new Thread的时候使用lambda表达式传入了Runnable的实现类对象，然后直接start开启线程
//1创建了MyRunnable对象 里面存放了要执行的任务
MyRunnable r = new MyRunnable();
//2创建线程对象 把Runnable对象r传入线程里
//相当于把任务交给了线程
Thread t = new Thread(r);
//3 开启线程 会执行Runnable对象里的run方法
t.start();
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("吃西瓜" + i);
System.out.println(Thread.currentThread().getName());
}
});
t2.start();
new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("喝豆浆" + i);
System.out.println(Thread.currentThread().getName());
}
}).start();1.4.5. 两种实现方式的区别
- 第一种方式：需要自定义类，继承Thread类——子类不能再继承其它类了，比较受限制！
- 第二种方式：需要自定义类，实现Runnable接口——对于子类更灵活,更方便代码的面向对象设计。
1.4.6. 线程小结
1.5. 多线程方式三: 实现Callable接口
-
这种实现方式 适用于
任务有返回值的情况。 -
方法介绍
方法名 说明 V call() 计算结果，如果无法计算结果，则抛出一个异常 FutureTask(Callable callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable V get() 如有必要，等待计算完成，然后获取其结果 -
实现步骤
- 1定义一个类MyCallable实现Callable接口
- 2在MyCallable类中重写call()方法
- 3创建MyCallable类的对象
- 4创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 5创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 6启动线程
- 7FutureTask对象来调用get方法，就可以获取线程结束之后的结果。
1.5.1. 实现代码
- 定义一个类MyCallable实现Callable接口
- 重写call()方法 方法的内容就是要执行的子线程的任务
- 方法的返回值 可以在子线程结束后 获取
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("跟女孩表白" + i);
Thread.sleep(50);
}
//返回值就表示线程运行完毕之后的结果
return "答应";
}
}1.5.2. 测试代码
- 创建MyCallable类的对象 mc
- 创建FutureTask类的对象，把mc作为构造方法的参数传入
- 创建线程对象
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
MyCallable mc = new MyCallable();
//创建FutureTask对象ft 把mc传入，ft可以获取线程执行完毕之后的结果.
//FutureTask本身实现了Runnable接口
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象 ft作为参数传递给Thread对象
Thread t1 = new Thread(ft);
//System.out.println("1111");
//String s = ft.get();//代码 阻塞
//System.out.println("222");
//开启线程
t1.start();
System.out.println("等待表白结果");
String s = ft.get();
System.out.println(s);
}1.5.3. 执行原理
- 1 Thread线程对象 调用start方法 会执行run方法
- 2 在Thread里的run方法中,会调用runnable对象（这里传的是实现类FutureTask）的run方法
- 3 在FutureTask的run方法中 会调用callable对象的call方法
- 4 call方法调用完成后 会报返回值 保存到FutureTask对象里的成员变量中
- 5 如果需要这个返回值 就调用FutureTask对象的get方法就可以得到
1.5.4. 线程方法回顾
- 获取线程对象 Thread.currentThread();
- 获取线程名字 Thread.currentThread().getName();
- sleep线程休息 Thread.sleep(100);
1.5.5. 关于子类重写方法中声明异常的问题
- 如果子类的重写的方法声明一个编译期异常
- 那么对应的父类的被重写的方法 也要添加这个异常的声明
1.5.6. 在子线程里的异常,就要在子线程里try处理
- 注意下面的代码 是如法在run方法上进行声明的
public class Demo02 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
//在哪个线程产生的异常 就要在哪个线程处理掉
try {
sdf.parse("2022-10");
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
}).start();
}
}1.6. 线程状态
1.6.1. 6种线程状态
- 当线程被创建并启动以后，它既不是一启动就进入了
执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？ - Java中的线程状态被定义在了
java.lang.Thread.State枚举类中，State枚举类的源码如下：
public class Thread {
public enum State {
/* 新建 */
NEW ,
/* 可运行状态 */
RUNNABLE ,
/* 阻塞状态 */
BLOCKED ,
/* 无限等待状态 */
WAITING ,
/* 计时等待 */
TIMED_WAITING ,
/* 终止 */
TERMINATED;
}
// 获取当前线程的状态
public State getState() {
return jdk.internal.misc.VM.toThreadState(threadStatus);
}
}- 通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下
| 线程状态 | 具体含义 |
|---|---|
| NEW | 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程对象，没有线程特征。 |
| RUNNABLE | 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的调度。 |
| BLOCKED | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| WAITING | 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。 |
| TIMED_WAITING | 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。 |
| TERMINATED | 一个完全运行完成的线程的状态。也称之为终止状态、结束状态 |
1.6.2. 各个状态的转换
1.7. 线程优先级
1.7.1. 线程调度
-
两种调度方式
- 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
-
Java使用的是抢占式调度模型
-
随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
1.7.2. 相关方法
| 方法名 | 说明 |
|---|---|
| final int getPriority() | 返回此线程的优先级 |
| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
1.7.3. 代码
- 注意 优先级大，不一定先执行完，只是增加了抢占cpu的几率
// 子线程
DanceThread t01 = new DanceThread("ikun01");
SingThread t02 = new SingThread("ikun02");
t01.setPriority(Thread.MAX_PRIORITY);//设置为最大 10
t02.setPriority(Thread.MIN_PRIORITY);//设置为最小 1
System.out.println(t01.getPriority());//10
System.out.println(t02.getPriority());//1
t01.start();
t02.start();1.8. 守护线程 Daemon
- 用户线程，jvm会等待用户线程全部结束，最后再结束程序.
- 守护线程, 当所有用户线程都结束后，由于jvm直接结束程序，守护线程会被直接结束掉
- 垃圾回收器 就是一个守护线程
- 应用：一般写 有一些监控功能的需求。 比如定时器
1.8.1. 设置的方法
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出 |
1.8.2. 代码
- 1代码有两个子线程t1和t2,唱歌和打球，主线程跳舞
- 2 设置t1和t2为守护线程，那么当用户线程执行完后，如果守护线程任务没有执行完，守护线程也会结束
public class Demo04 {
public static void main(String[] args) {
MThread1 t1 = new MThread1();
//设置为守护线程
t1.setDaemon(true);
t1.start();
MThread2 t2 = new MThread2();
t2.setDaemon(true);
t2.start();
for (int i = 0; i < 100; i++) {
System.out.println("跳舞" + i);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("跳完了");
}
}
class MThread1 extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("唱歌" + i);
try {
sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("唱完了");
}
}
class MThread2 extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 100; i++) {
System.out.println("打篮球" + i);
try {
sleep(70);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("打完了");
}
}1.9. Thread.join()方法
- 作用：
- 阻塞主线程，直至join的线程执行完毕。
package link.xiaomo.test1;
public class Demo01 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("跳舞");
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("唱歌");
}
});
t1.start();
t2.start();
try {
t1.join(); //等待子线程t1 执行完毕 注意t2会正常运行
t2.join(); //等待子线程t2 执行完毕 注意t2可能在等待t1的时候 就已经结束了
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("吃饭睡觉");
}
}
2. 线程安全问题
当多个线程共同运行的时候，就可能出现
线程安全问题，我们接下通过一个案例来讲述一下这个问题。
2.1. 卖票案例
2.1.1. 案例需求
- 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
2.1.2. 实现步骤
- 1定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100; 表示票的数量
- 2 在SellTicket类中重写run()方法实现卖票，代码步骤如下
- 添加死循环，表示一直在买卖票
- 判断票数大于0，就卖票，并告知是哪个窗口卖的
- 卖了票之后，总票数要减1
- 票数小于等于0，线程停止
- 3 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
- 创建SellTicket类的对象
- 创建三个Thread类的对象，给线程定义名字为窗口1、窗口2、窗口3，把SellTicket对象作为构造方法的参数分别传给三个线程对象。
- 4启动3个线程
2.1.3. 代码
- 注意：
- 代码中有三个线程对象，Runnable对象只有一个
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
while (true) {
if(ticket <= 0){
//判断ticket数量小于等于0，说明卖完了，结束循环
break;
}else{
try {
Thread.sleep(100);//模拟卖票消耗100ms
} catch (InterruptedException e) {
e.printStackTrace();
}
ticket--;//卖票 导致数量-1
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st = new SellTicket();
//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
}
}2.1.4. 卖票案例的问题
- 卖票出现了问题
- 相同的票出现了多次
- 票数增长现象
- 出现了负数的票
- 问题产生原因
- 多个线程执行的随机性导致的,可能在卖票过程中丢失cpu的执行权,导致出现问题
2.1.5. 解决方案：
- 安全问题出现的条件
- 多线程环境
- 有
共享数据，比如上面案例中的票的数量 - 有多条语句操作共享数据
- 如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境，即让上述任意条件不成立
- 怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
基于此，我们提供了三种解决线程安全问题的方案：
- 同步代码块
- 同步方法
- Lock锁
接下来，我们将一一讲解这三种方法
2.2. 解决方案一：同步代码块(synchronized)
-
Java提供了
同步代码块的方式来解决线程安全问题 -
同步代码块格式：
synchronized(任意对象) {
多条语句操作共享数据的代码
}- synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
- 多个线程操作同一个代码块，要保证对象锁是同一个。
2.2.1. 代码
- 注意 是操作共享数据的那块代码 放到同步代码块中
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}2.2.2. 图解
2.2.3. 同步的好处和弊端
-
好处：解决了多线程的数据安全问题
-
弊端：当线程很多时，多个线程来回切换,每个线程还会去判断同步上的锁，这是很
耗费资源的，无形中会降低程序的运行效率, 比单线程还要慢
2.3. 解决方案二：同步方法
2.3.1. 同步方法的格式
- 同步方法：就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) {
方法体；
}同步方法的锁对象是什么呢?
其实就是this，即对象本身
2.3.2. 静态同步方法
- 同步静态方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体；
}-
同步静态方法的锁对象是什么呢? 是类名.class
2.3.3. 代码实现
package link.xiaomo.test0;
public class SellTicket implements Runnable {
private int tickets = 100;//票的总数量
//卖票的任务
@Override
public void run() {
//写一个死循环 卖票
while (true) {
//获取返回值用来判断是否卖完票
boolean isStop = sell();
//如果卖完了票 就结束循环
if (isStop)
break;
}
}
//同步方法 设置返回值为布尔类型 如果返回true表示票卖完了,退出循环
public synchronized boolean sell() {
//判断票数如果为0 就停止卖票
if (tickets <= 0) {
return true;
} else {
try {
//模拟卖票耗时100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//如果不为0 就卖出去一张票
String name = Thread.currentThread().getName();
tickets--;
System.out.println(name + "卖出去一张票,还剩" + tickets + "张");
return false;
}
}
}2.3.4. 测试代码
- 同步方法的锁都是this，也就是当前的runnable对象mr
public class Demo {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("窗口一");
t2.setName("窗口二");
t1.start();
t2.start();
}
}
2.3.5. 演示：同步方法的锁是this
- 线面代码addNum和numAdd在不同的线程里运行
- 一个使用了同步代码块 一个用了同步方法.
- 经过验证 同步方法的锁的确是this
package link.xiaomo.test0;
public class MyTask {
private int num = 0;
public void addNum() {
synchronized (this) {
for (int i = 0; i < 100000; i++) {
num++;
}
System.out.println(Thread.currentThread().getName() + "----" + num);
}
}
//同步方法的锁是this
public synchronized void numAdd() {
for (int i = 0; i < 100000; i++) {
num++;
}
System.out.println(Thread.currentThread().getName() + "----" + num);
}
}
- 测试
package link.xiaomo.test0;
public class Demo02 {
public static void main(String[] args) {
MyTask task = new MyTask();
new Thread(() -> {
task.addNum();
}).start();
new Thread(() -> {
task.numAdd();
}).start()
}
}2.4. 解决方案三：Lock锁（Reentrant）
-
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
-
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
-
ReentrantLock构造方法
方法名 说明 ReentrantLock() 创建一个ReentrantLock的实例 -
加锁解锁方法
方法名 说明 void lock() 获得锁 void unlock() 释放锁
2.4.1. 代码实现
- lock.lock()加锁
- 释放锁lock.unlock(); 一般写在finally中保证正常执行
package link.xiaomo.test3;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicket implements Runnable {
private int tickets = 100;//票的总数量
//创建锁的对象
private ReentrantLock lock = new ReentrantLock();
//卖票的任务
@Override
public void run() {
//写一个死循环 卖票
while (true) {
try {
//加锁
lock.lock();
if (tickets <= 0) {
break;
} else {
try {
//模拟卖票耗时100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//如果不为0 就卖出去一张票
String name = Thread.currentThread().getName();
tickets--;
System.out.println(name + "卖出去一张票,还剩" + tickets + "张");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
lock.unlock();
}
}
}
}
public class Demo {
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("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}2.4.2. 死锁(理解产生原因)
- 在一个锁里嵌套添加另外一个锁
- 当多线程时，导致都卡到两个锁的中间，程序停滞处于等待状态
public static void main(String[] args) {
Object objA = new Object();
Object objB = new Object();
new Thread(()->{
while(true){
synchronized (objA){
//线程一
System.out.println("小康进入a");
synchronized (objB){
System.out.println("小康进入b");
System.out.println("小康同学正在走路");
}
}
}
}).start();
new Thread(()->{
while(true){
synchronized (objB){
//线程二
System.out.println("小薇进入B");
synchronized (objA){
System.out.println("小薇进入A");
System.out.println("小薇同学正在走路");
}
}
}
}).start();
}3. 线程通信 : 生产者消费者
3.1. 引言
什么是线程通信？
- 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。
常见模式：生产者与消费者模型
- 生产者线程负责生成数据
- 消费者线程负责消费生产者生成的数据
- 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。
Object类的等待和唤醒方法
| 方法名 | 说明 |
|---|---|
| void wait() | 导致当前线程等待，wait会释放同步锁, 直到另一个线程调用该对象的 notify()方法或 notifyAll()方法， |
| void notify() | 唤醒正在等待对象监视器的单个线程 |
| void notifyAll() | 唤醒正在等待对象监视器的所有线程 |
3.2. 案例
比如下面的经典案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。
接下来，我们先分析一下完成这个案例的思路
1.先确定在这个案例中，什么是共享数据？
答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。2.再确定有那几条线程？哪个是生产者，哪个是消费者？
答：厨师是生产者线程，3条生产者线程；
顾客是消费者线程，2条消费者线程3.什么时候将哪一个线程设置为什么状态
生产者线程(厨师)放包子：
1)先判断是否有包子
2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待
3)有包子时，不做包子了，直接唤醒别人、然后让自己等待消费者线程(顾客)吃包子：
1)先判断是否有包子
2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待
3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待
按照上面分析的思路写代码。先写桌子类，代码如下
package link.xiaomo.test2;
import java.util.ArrayList;
import java.util.List;
public class Desk {
private List<String> list = new ArrayList<>();
// 放1个包子的方法
// 厨师1 厨师2 厨师3
public synchronized void put() {
try {
String name = Thread.currentThread().getName();
// 判断是否有包子。
if (list.size() == 0) {
list.add(name + "做的肉包子");
System.out.println(name + "做了一个肉包子~~");
Thread.sleep(2000);
System.out.println(name + "包子做好了,进入等待,唤醒其它线程");
// 唤醒别人, 自己等待 a b c 吃货1 吃货2
this.notifyAll();
//wait可以让当前线程在这里停止,并且把锁释放
this.wait();
} else {
// 有包子了，不做了。
// 唤醒别人, 等待自己
this.notifyAll();
this.wait();
System.out.println(name + "进入等待,唤醒其它线程");
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 吃货1 吃货2
public synchronized void get() {
try {
String name = Thread.currentThread().getName();
if (list.size() == 1) {
// 有包子，吃了
System.out.println(name + "开始吃：" + list.get(0));
list.clear();
Thread.sleep(1000);
System.out.println(name + "包子吃完了,进入等待,唤醒其它线程");
this.notifyAll();//通知厨师线程做包子,也有可能是其它吃货抢到了执行权
this.wait();
} else {
// 没有包子
System.out.println(name + "没有包子了,进入等待,唤醒其它线程");
this.notifyAll();//通知厨师线程做包子,也有可能是其它吃货抢到了执行权
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程
public class ThreadTest {
public static void main(String[] args) {
// 需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
// 2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
Desk desk = new Desk();
// 创建3个生产者线程（3个厨师）
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师1").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师2").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师3").start();
// 创建2个消费者线程（2个吃货）
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货1").start();
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货2").start();
}
}执行上面代码，运行结果如下：你会发现多个线程相互协调执行，避免无效的资源挣抢。
厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子
Comments NOTHING