最新Java基础系列课程--Day14-多线程编程（一）https://developer.aliyun.com/article/1423550
我们再尝试，把join()方法去掉，再看执行效果。此时你会发现2号线程没有执行完1号线程就执行了**（效果是多次运行才出现的，根据个人电脑而异，可能有同学半天也出现不了也是正常的）**
三、线程安全问题
各位小伙伴，前面我们已经学习了如何创建线程，以及线程的常用方法。接下来，我们要学习一个在实际开发过程中，使用线程时最重要的一个问题，叫线程安全问题。
3.1 线程安全问题概述
- 首先，什么是线程安全问题呢？
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。
下面通过一个取钱的案例给同学们演示一下。案例需求如下
场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？
如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的
① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。
② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。
③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。
④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。
你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！
以上取钱案例中的问题，就是线程安全问题的一种体现。
3.2 线程安全问题的代码演示
先定义一个共享的账户类
public class Account { private String cardId; // 卡号 private double money; // 余额。 public Account() { } public Account(String cardId, double money) { this.cardId = cardId; this.money = money; } // 小明 小红同时过来的 public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } } public String getCardId() { return cardId; } public void setCardId(String cardId) { this.cardId = cardId; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } }
在定义一个是取钱的线程类
public class DrawThread extends Thread{ private Account acc; public DrawThread(Account acc, String name){ super(name); this.acc = acc; } @Override public void run() { // 取钱(小明，小红) acc.drawMoney(100000); } }
最后，再写一个测试类，在测试类中创建两个线程对象
public class ThreadTest { public static void main(String[] args) { // 1、创建一个账户对象，代表两个人的共享账户。 Account acc = new Account("ICBC-110", 100000); // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。 new DrawThread(acc, "小明").start(); // 小明 new DrawThread(acc, "小红").start(); // 小红 } }
运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10完了。
3.3 线程同步方案
为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。
等小红线程执行完了，把余额改为0，出去了就会释放锁。这时小明线程就可以加锁进来执行，如下图所示。
采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案
1.同步代码块 2.同步方法 3.Lock锁
2.4 同步代码块
我们先来学习同步代码块。它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。
//锁对象：必须是一个唯一的对象（同一个地址） synchronized(锁对象){ //...访问共享数据的代码... }
使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。
// 小明 小红线程同时过来的 public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 // this正好代表共享资源！ 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 + "来取钱：余额不足~"); } } }
此时再运行测试类，观察是否会出现不合理的情况。
最后，再给同学们说一下锁对象如何选择的问题
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象 2.对于实例方法，建议使用this作为锁对象 3.对于静态方法，建议把类的字节码(类名.class)当做锁对象
2.5 同步方法
接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。
// 同步方法 public synchronized void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); // 1、判断余额是否足够 if(this.money >= money){ System.out.println(name + "来取钱" + money + "成功！"); this.money -= money; System.out.println(name + "来取钱后，余额剩余：" + this.money); }else { System.out.println(name + "来取钱：余额不足~"); } }
改完之后，再次运行测试类，观察是否会出现不合理的情况。
接着，再问同学们一个问题，同步方法有没有锁对象？锁对象是谁？
同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。 1.对于实例方法，锁对象其实是this（也就是方法的调用者） 2.对于静态方法，锁对象时类的字节码对象（类名.class）
最终，总结一下同步代码块和同步方法有什么区别？
1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小 2.同步方法是将方法中所有的代码锁住 3.同步代码块是将方法中的部分代码锁住
2.6 Lock锁
接下来，我们再来学习一种，线程安全问题的解决办法，叫做Lock锁。
Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下
1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象） private final Lock lk = new ReentrantLock(); 2.在需要上锁的地方加入下面的代码 lk.lock(); // 加锁 //...中间是被锁住的代码... lk.unlock(); // 解锁
使用Lock锁改写前面DrawThread中取钱的方法，代码如下
// 创建了一个锁对象 private final Lock lk = new ReentrantLock(); public void drawMoney(double money) { // 先搞清楚是谁来取钱？ String name = Thread.currentThread().getName(); try { lk.lock(); // 加锁 // 1、判断余额是否足够 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) { e.printStackTrace(); } finally { lk.unlock(); // 解锁 } } }
运行程序结果，观察是否有线程安全问题。到此三种解决线程安全问题的办法我们就学习完了。
四、线程通信（了解）
接下来，我们学习一下线程通信。
首先，什么是线程通信呢？
- 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。
线程通信的常见模式：是生产者与消费者模型
- 生产者线程负责生成数据
- 消费者线程负责消费生产者生成的数据
- 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。
比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。
接下来，我们先分析一下完成这个案例的思路
1.先确定在这个案例中，什么是共享数据？ 答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。 2.再确定有那几条线程？哪个是生产者，哪个是消费者？ 答：厨师是生产者线程，3条生产者线程； 顾客是消费者线程，2条消费者线程 3.什么时候将哪一个线程设置为什么状态 生产者线程(厨师)放包子： 1)先判断是否有包子 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待 消费者线程(顾客)吃包子： 1)先判断是否有包子 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待
按照上面分析的思路写代码。先写桌子类，代码如下
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); // 唤醒别人, 等待自己 this.notifyAll(); this.wait(); }else { // 有包子了，不做了。 // 唤醒别人, 等待自己 this.notifyAll(); this.wait(); } } 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); this.notifyAll(); this.wait(); }else { // 没有包子 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做的肉包子
最新Java基础系列课程--Day14-多线程编程（三）https://developer.aliyun.com/article/1423552
