【Java并发002】使用层面（线程同步与线程通信全解析）
一、前言
本文介绍Java多线程技术，分为五个部分：
多线程的两种实现方式——继承Thread类和实现Runnable接口；
线程同步应用：三人吃苹果；
线程同步+线程通信应用之一：生产者-消费者问题；
线程同步+线程通信应用之二：打蜡抛光问题；
线程同步+线程通信之用之三：哲学家就餐问题。
二、初识多线程
上小学的时候，语文老师让我们用"一边......,一边......"造句，比如“小明一边吃饭，一边看电视”、“妈妈一边做饭，一边和我闲谈”。那么Java程序中是否可以实现“程序一边xxx一边xxx”呢？答案是肯定，这就是Java的多线程技术
2.1 引子：小明一边玩游戏一边听音乐
实现多线程有两种常见的方式，
1、继承线程类（extends Thread）:某类继承线程类之后，该类成为线程类，拥有独立的线程空间并可以执行;
2、实现Runnable接口（implements Runnable）:某类实现Runnable接口后，可以实现多线程，注意它不是多线程类，只是具有多线程方法。但是可以满足我们目前的需求就够了。
值得注意的是，Java的main函数作为程序的入口，本身就是一个Main线程，我们可以将该线程作为一个游戏线程，然后只需要新建一个MusicThread类就够了。
代码：
package mypackage;
public class MainThread {
public static void main(String[] args) {
new MusicThread().start();
for (int i = 0;
i < 3;
i++) {
System.out.println("Playing ComputerGame" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MusicThread extends Thread {
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Listening Music" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出：
Playing ComputerGame0
Listening Music0
Playing ComputerGame1
Listening Music1
Playing ComputerGame2
Listening Music2
注意：Thread.Sleep(1000) 睡眠一秒钟是为了让多线程交替执行的效果在控制台打印出来，如果没有这句，可能出现某个线程执行完后另一个线程才开始执行，无法给读者展示多线程"一边xxx一边xxx"的效果。
2.2 实现多线程的两种方式 2.2.1 继承Thread类：扩展——小明一边玩游戏一边听音乐，还一边用QQ和小强聊天
如果要再扩展一个线程也很简单，来看代码。
代码：
package mypackage1;
public class MainThread {
public static void main(String[] args) {
new MusicThread().start();
new QQThread().start();
for (int i = 0;
i < 3;
i++) {
System.out.println("Playing ComputerGame" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MusicThread extends Thread {
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Listening Music" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class QQThread extends Thread{
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Chating in QQ" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出：
Listening Music0
Playing ComputerGame0
Chating in QQ0
Listening Music1
Playing ComputerGame1
Chating in QQ1
Listening Music2
Playing ComputerGame2
Chating in QQ2
【【Java并发002】使用层面（线程同步与线程通信全解析）】相对上面，扩展了QQThread，用于qq聊天，可以看到，要新增一个新的线程类也是很容易的。
2.2.2 实现Runnable接口
代码：
package mypackage2;
public class MainThread {
public static void main(String[] args) {
new Thread(new MusicRunnableImpl()).start();
new Thread(new QQRunnableImpl()).start();
for (int i = 0;
i < 3;
i++) {
System.out.println("Playing ComputerGame" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MusicRunnableImpl implements Runnable {
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Listening Music" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class QQRunnableImpl implements Runnable{
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Chating in QQ" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出：
Playing ComputerGame0
Chating in QQ0
Listening Music0
Listening Music1
Playing ComputerGame1
Chating in QQ1
Listening Music2
Chating in QQ2
Playing ComputerGame2
这里通过实现Runnable接口，实现多线程，是实现多线程的另一种常见方式。
2.3 实现多线程的两种方式（匿名方式） 2.3.1 继承Thread类（匿名内部类）
代码——匿名方式的Thread类：
package package3;
public class MainThread {
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Listening Music" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread(){
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Chating in QQ" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
for (int i = 0;
i < 3;
i++) {
System.out.println("Playing ComputerGame" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出：
Listening Music0
Playing ComputerGame0
Chating in QQ0
Listening Music1
Playing ComputerGame1
Chating in QQ1
Listening Music2
Playing ComputerGame2
Chating in QQ2
2.3.2 实现Runnable接口（匿名内部类）
代码：
package mypackage4;
public class MainThread {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Listening Music" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0;
i < 3;
i++) {
System.out.println("Chating in QQ" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
for (int i = 0;
i < 3;
i++) {
System.out.println("Playing ComputerGame" + i);
try {
Thread.sleep(1000);
// 这里Sleep() 让线程交互明显
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出：
Listening Music0
Playing ComputerGame0
Chating in QQ0
Playing ComputerGame1
Chating in QQ1
Listening Music1
Chating in QQ2
Playing ComputerGame2
Listening Music2
2.4 小结 多线程在默认的Main线程中额外添加一个或多个线程对象并执行，提供了一种将单一线程程序中无法解决的并发问题完美解决的方案，在实际项目开发中应用广泛。多线程是Java语言的又一特色。
三、线程同步 多个线程访问同一资源，如我们来讨论一下“三人吃苹果”的例子。
3.1 引子：三人吃苹果问题 上一节我们说到，实现多线程常见的有两种方式，继承Threads和实现Runnable接口，这里我们两种方式都尝试一样，先看继承Threads类：
3.1.1 继承Thread类：三人吃苹果问题
代码：
public class Test {
public static void main(String[] args) {
new Apple().start();
new Apple().start();
new Apple().start();
}
}
// 继承线程类 num 为每个Person对象的内部变量 不能共享
class Apple extends Thread {
private int num = 5;
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "吃了编号为" + (num--) + "的苹果");
}
}
}
}
输出：
Thread-1吃了编号为5的苹果
Thread-2吃了编号为5的苹果
Thread-0吃了编号为5的苹果
Thread-2吃了编号为4的苹果
Thread-1吃了编号为4的苹果
Thread-2吃了编号为3的苹果
Thread-2吃了编号为2的苹果
Thread-2吃了编号为1的苹果
Thread-0吃了编号为4的苹果
Thread-1吃了编号为3的苹果
Thread-1吃了编号为2的苹果
Thread-0吃了编号为3的苹果
Thread-1吃了编号为1的苹果
Thread-0吃了编号为2的苹果
Thread-0吃了编号为1的苹果
小结：我们看到每个苹果被吃了三次，这是为什么呢？原来，我们在客户端新建三个独立的Apple类对象，每一个Apple都有一个私有的num变量，三个线程都在吃自己的苹果，然后num--。在这个过程中，苹果是独立的而不是共享的，这显然不是我们所需要的情况。
让我们尝试使用实现Runnable接口完成这个“三人吃苹果”问题。
3.1.2 实现Runnable接口：三人吃苹果问题
代码：
public class Test {
public static void main(String[] args) {
Apple apple=new Apple();
//虽然三个线程但是使用同一个apple引用
new Thread(apple,"Thread-0").start();
new Thread(apple,"Thread-1").start();
new Thread(apple,"Thread-2").start();
}
}
//实现Runnable接口只是多线程方法不是多线程类所有num变量可以让Person对象共享
class Apple implements Runnable{
private int num=5;
@Override
public void run() {
for (int i=0;
i<5;
i++){
if (num>0) {
System.out.println(Thread.currentThread().getName()+"吃了编号为"+(num--)+"的苹果");
}
}
}
}
输出：
Thread-0吃了编号为5的苹果
Thread-1吃了编号为4的苹果
Thread-2吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-1吃了编号为1的苹果
小结：乍看之下好像没有任何问题，
从代码上来看，客户端仅新建一个Apple对象，然后将它的引用传递给三个线程对象，这样就实现了的三个线程类对苹果的共享；
从输出结果上来看，被吃掉的苹果的序号为 5 4 3 2 1 ，如何的完美，而且是被三个线程Thread-0,Thread-1,Thread-2,“三人吃苹果”的故事似乎完结了。
实则不然，这里只是因为num=5,数值太小，加上我们运气比较好，恰好获得了一次看上去完美的输出结果。程序再运行几次：
Thread-0吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-0吃了编号为1的苹果
Thread-1吃了编号为5的苹果
Thread-2吃了编号为4的苹果
咦，为什么最先吃掉了编号为3的苹果，其他苹果的顺序也变乱了，再运行一次：
Thread-0吃了编号为4的苹果
Thread-0吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-1吃了编号为5的苹果
Thread-2吃了编号为5的苹果
Thread-0吃了编号为1的苹果
这一次更糟糕了，不仅吃苹果的顺序变乱了，而且编号为5的苹果竟然被吃了两次
其实我们还可以让程序更乱一些：加上Thread.sleep(毫秒数)
注意：Java多线程的最常见的两种实现方式：继承Thread类和实现Runnable接口，其异同我们在这里看出来了
文章图片
image.png 3.1.3 加上Thread.sleep(毫秒数)
代码：
public class Test {
public static void main(String[] args) {
Apple apple=new Apple();
//虽然三个线程但是使用同一个apple引用
new Thread(apple,"Thread-0").start();
new Thread(apple,"Thread-1").start();
new Thread(apple,"Thread-2").start();
}
}
//实现Runnable接口只是多线程方法不是多线程类所有num变量可以让Person对象共享
class Apple implements Runnable{
private int num=5;
@Override
public void run() {
for (int i=0;
i<5;
i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (num>0) {
System.out.println(Thread.currentThread().getName()+"吃了编号为"+(num--)+"的苹果");
}
}
}
}
喔喔喔，这次更是千奇百怪的答案，基本没有一次对的，为什么会这样呢？这样解决呢？
解答：这个问题是因为多线程程序运行的随机性造成的，只要使用相应的互斥同步机制就好了。
3.2 线程同步——三人吃苹果问题解决 问题：
对于三人吃苹果问题，我们通过实现Runnable接口，三人共享5个苹果，但是出现一个苹果吃多次的情况，这不满足的业务需求。其原因是因为每个人吃苹果不是一个原子操作：即System.out.println(Thread.currentThread().getName()+"吃了编号为 "+(num--)+" 的苹果"); 可以拆分为两句，如下：
System.out.println(Thread.currentThread().getName()+"吃了编号为 "+(num)+" 的苹果");
num--;
这两句不是原子操作，可以被打断。
解决：
使用Java线程同步的方式解决，线程的同步机制有三种：同步代码块、同步方法和lock锁机制
3.2.1 代码——同步代码块
代码：
//同步代码块/同步方法/lock机制
public class Test {
public static void main(String[] args) {
Apple apple=new Apple();
//虽然三个线程但是使用同一个apple引用
new Thread(apple,"Thread-0").start();
new Thread(apple,"Thread-1").start();
new Thread(apple,"Thread-2").start();
}
}
//实现Runnable接口只是多线程方法不是多线程类所有num变量可以让Person对象共享
class Apple implements Runnable{
private int num=5;
@Override
public void run() {
for (int i=0;
i<5;
i++){
synchronized (this) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num>0) {
System.out.println(Thread.currentThread().getName()+"吃了编号为"+(num--)+"的苹果");
}
}
}
}
}
输出：
Thread-0吃了编号为5的苹果
Thread-0吃了编号为4的苹果
Thread-0吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-0吃了编号为1的苹果
小结：即使多次运行，输出结果仍是这样有条不紊。这是为什么呢？
原来我们在代码2中的出现的问题（打印的编号顺序错乱，同一苹果被吃掉两次）均是因为某一线程运行时System.out.prinln()和num--不能同时运行，中间有间断，这一间断中，其他线程又执行了System.out.prinln和num--,才出现各种错乱问题。
特别是加入Thread.sleep()方法后，Thread.sleep System.out.prinln num-- 三者不能一起执行，各个出错只多不少。
现在，因为我们程序中加入了synchronized关键字，这是线程同步的关键字，如代码4中，synchronized关键字后面的花括号将Thread.sleep(1000)和System.out.println(num--)包裹起来，意思就是将它们打包，放在一起作为原子操作，要么两个一起执行，要么都不执行，从根本上杜绝了Thread.sleep System.out.prinln num-- 一套操作被打断的可能，所以保证了多线程的安全。
附：为什么synchronized后面有一个小括号，里面还有一个this呢？
解答：这就是同步锁对象，是同步代码块得以成功实现线程同步的必要条件，因为在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着。
注意1： 对于非static方法,同步锁就是this；对于static方法,我们使用当前方法所在类的字节码对象(Apple.class).
注意2：Java程序运行使用任何对象作为同步监听对象,但是一般的,我们把当前并发访问的共同资源作为同步监听对象.
让我们再来看看其他两种方法：同步方法和同步代码块吧！
3.2.2 代码——同步方法
代码：
public class Test {
public static void main(String[] args) {
Apple apple = new Apple();
// 虽然三个线程 但是使用同一个apple引用
new Thread(apple, "Thread-0").start();
new Thread(apple, "Thread-1").start();
new Thread(apple, "Thread-2").start();
}
}
// 实现Runnable接口 只是多线程方法 不是多线程类 所有 num变量可以让Person对象共享
class Apple implements Runnable {
private int num = 5;
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
eat();
}
}
private synchronized void eat() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "吃了编号为" + (num--) + "的苹果");
}
}
}
输出：
Thread-0吃了编号为5的苹果
Thread-0吃了编号为4的苹果
Thread-0吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-0吃了编号为1的苹果
小结：当我们把synchronized关键字放在方法名上，同样达到了我们多线程安全的效果。
注意1：synchronized范围越大，效率越低
注意2：synchronized 范围内的操作的原子性只对其他synchronized方法或块有用，对非synchronized方法或块没有用；即synchronized只是保证其他synchronized方法不打断当前synchronized操作，不保证其他非synchronized方法或块不打断当前synchronized操作。其实，读者担心synchronized被非synchronized打断是不是一种风险，其实不用担心，因为既然它是非synchronized,就是说明它访问变量和当前的synchronized访问的变量在业务逻辑上基本没有关系，打断就打断呗，如果业务上有逻辑关系，影响到业务了，就给非synchronized方法或块加上synchronized，就防止打断了，就是这么简单！
3.2.3 代码——lock锁机制
代码：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
Apple apple = new Apple();
// 虽然三个线程 但是使用同一个apple引用
new Thread(apple, "Thread-0").start();
new Thread(apple, "Thread-1").start();
new Thread(apple, "Thread-2").start();
}
}
// 实现Runnable接口 只是多线程方法 不是多线程类 所有 num变量可以让Person对象共享
class Apple implements Runnable {
private int num = 5;
privatefinal Lock _lock=new ReentrantLock();
@Override
public void run() {
for (int i=0;
i<5;
i++){
_lock.lock();
try {
Thread.sleep(1000);
if (num>0) {
System.out.println(Thread.currentThread().getName()+"吃了编号为"+(num--)+"的苹果");
}
}catch (InterruptedException e) {e.printStackTrace();
}finally {
_lock.unlock();
}
}
}
}
输出：
Thread-0吃了编号为5的苹果
Thread-0吃了编号为4的苹果
Thread-0吃了编号为3的苹果
Thread-0吃了编号为2的苹果
Thread-0吃了编号为1的苹果
小结：使用lock机制和使用synchronized关键字达到了相同的效果，它们的原理是一样的吗？其实不是，具体的关于synchronized和lock的底层实现，笔者在其他博客中再去阐述。
3.3 小结 截至现在，我们搞懂了“三人吃苹果”问题中，三个线程访问同一资源类对象，修改其内部num变量，注意两点：
1、资源对象实现Runnable接口而不是继承Thread，因为继承Thread类新建的对象不好引用；
2、要使用相应的同步机制（同步代码块、同步方法、lock锁机制）保证线程安全，正确执行。
四、线程同步+线程通信应用之一：生产者-消费者问题 上一节，我们说到，“三人吃苹果”实际上是三个线程都在消费Apple类中num属性，每消费一次，num--。
本文中加上生产者，生产线程Producer生产苹果Apple，消费线程Consumer消费苹果Apple。
4.1 实现线程通信的两种方式 4.1.1 实现方式一：生产者将生产的产品直接交给消费者消费
实现方式一代码：
//生产者
classProducer{
privateConsumercon;
//消费者对象
}
//消费者
classConsumer{
privateProducerpro;
//消费者对象
}
该代码使用双向注入，将消费者引用注入
4.1.2 实现方式二：单独设置一个共享资源类，生产者类生产的产品放入共享资源中，消费者类从共享资源中取出消费
代码：
package mypackage;
public class Test {
public static void main(String[] args) {
ShareResources shareResources = new ShareResources();
new Thread(new Producer(shareResources)).start();
new Thread(new Consumer(shareResources)).start();
}
}
class Producer implements Runnable {
private ShareResources shareResources = null;
public Producer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
shareResources.push("春哥哥", "男");
} else {
shareResources.push("凤姐", "女");
}
}
}
}
class Consumer implements Runnable {
private ShareResources shareResources = null;
public Consumer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
shareResources.pop();
}
}
}
class ShareResources {
private String name;
private String gender;
public void push(String name, String gender) {
this.name = name;
try {
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.gender = gender;
}
public void pop() {
System.out.print(this.name + " - ");
try {
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.gender);
}
}
输出：
春哥哥 - null
凤姐 - 男
凤姐 - 男
凤姐 - 男
春哥哥 - 女
问题（1）：性别紊乱问题？
解决（1）：这是因为打印的时候没有原子性操作，可以使用synchronized或lock机制解决
问题（2）：“春哥哥 - 男” “凤姐 - 女” 没有按照 0==i%2 循环交替出现？
解决（2）：没有实现合理的线程通信，可以使用 wait()-notifyAll() 或者 await()-signalAll() 解决
4.2 生产者-消费者问题：synchronized+标志位+wait()+notify()/notifyAll() 4.2.1 使用synchronized实现线程同步
代码：
package mypackage_synchronized实现线程同步;
public class Test {
public static void main(String[] args) {
ShareResources shareResources = new ShareResources();
new Thread(new Producer(shareResources)).start();
new Thread(new Consumer(shareResources)).start();
}
}
class Producer implements Runnable {
private ShareResources shareResources = null;
public Producer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
shareResources.push("春哥哥", "男");
} else {
shareResources.push("凤姐", "女");
}
}
}
}
class Consumer implements Runnable {
private ShareResources shareResources = null;
public Consumer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
shareResources.pop();
}
}
}
class ShareResources {
private String name;
private String gender;
public synchronized void push(String name, String gender) {
this.name = name;
try {
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.gender = gender;
}
public synchronized void pop() {
System.out.print(this.name + " - ");
try {
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.gender);
}
}
输出：
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
小结：不会再出现性别紊乱问题，因为push()和pop()已经实现原子操作，但是还是没有实现0==i%2 交替打印，且看4.2.3。
4.2.3 synchronize+标志位+wait()+notifyAll() 实现线程同步与线程通信
代码：
package mypackage_synchronized_wait_notify;
public class Test {
public static void main(String[] args) {
ShareResources shareResources = new ShareResources();
new Thread(new Producer(shareResources)).start();
new Thread(new Consumer(shareResources)).start();
}
}
class Producer implements Runnable {
private ShareResources shareResources = null;
public Producer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
shareResources.push("春哥哥", "男");
} else {
shareResources.push("凤姐", "女");
}
}
}
}
class Consumer implements Runnable {
private ShareResources shareResources = null;
public Consumer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
shareResources.pop();
}
}
}
class ShareResources {
private String name;
private String gender;
private boolean isEmpty = true;
// 初始的时候资源池为空
public synchronized void push(String name, String gender) {
try {
while (!isEmpty) { // 资源池非空状态下 push要一直等待
wait();
}
this.name = name;
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
this.gender = gender;
isEmpty = false;
// 资源池不为空了，修改标志位的值
notifyAll();
// notify()唤醒一个，notifyAll()唤醒所有，本程序中只有一个生产者和消费者对象，所以notify()和notifyAll()是一样的
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void pop() {
try {
while (isEmpty) { // 当资源池为空时，pop()方法一直等待
wait();
}
System.out.print(this.name + " - ");
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
System.out.println(this.gender);
isEmpty = true;
// 资源被消费掉，资源池为空，重新设置标志位
notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出：
春哥哥 - 男
凤姐 - 女
春哥哥 - 男
凤姐 - 女
春哥哥 - 男
小结：synchronize+标志位+wait()+notifyAll() 实现线程同步与线程通信，解决好了生产者与消费者问题。我们可以尝试使用lock+标志位+await()+signalAll() 再实现一次，即更换一种方式实现生产者消费者问题，且看4.3.1 和4.3.2 。
4.3 生产者-消费者问题：lock+标志位+await()+signal()/signalAll() 4.3.1 使用lock实现线程同步
代码：
package mypackage_lock机制实现线程同步;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
ShareResources shareResources = new ShareResources();
new Thread(new Producer(shareResources)).start();
new Thread(new Consumer(shareResources)).start();
}
}
class Producer implements Runnable {
private ShareResources shareResources = null;
public Producer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
shareResources.push("春哥哥", "男");
} else {
shareResources.push("凤姐", "女");
}
}
}
}
class Consumer implements Runnable {
private ShareResources shareResources = null;
public Consumer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
shareResources.pop();
}
}
}
class ShareResources {
private String name;
private String gender;
private final Lock lock = new ReentrantLock();
public void push(String name, String gender) {
lock.lock();
try {
this.name = name;
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
this.gender = gender;
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void pop() {
lock.lock();
try {
System.out.print(this.name + " - ");
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
System.out.println(this.gender);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
输出：
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
春哥哥 - 男
小结：不会再出现性别紊乱问题，因为push()和pop()已经实现原子操作，但是还是没有实现0==i%2 交替打印，且看4.3.2 。
4.3.2 lock+标志位+await()+signalAll() 实现线程同步与线程通信
代码：
package mypackage_lock_await_signal;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
ShareResources shareResources = new ShareResources();
new Thread(new Producer(shareResources)).start();
new Thread(new Consumer(shareResources)).start();
}
}
class Producer implements Runnable {
private ShareResources shareResources = null;
public Producer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
shareResources.push("春哥哥", "男");
} else {
shareResources.push("凤姐", "女");
}
}
}
}
class Consumer implements Runnable {
private ShareResources shareResources = null;
public Consumer(ShareResources shareResources) {
this.shareResources = shareResources;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
shareResources.pop();
}
}
}
class ShareResources {
private String name;
private String gender;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private boolean isEmpty = true;
// 初始的时候资源池为空
public void push(String name, String gender) {
lock.lock();
try {
while (!isEmpty) { // 资源池非空状态下 push要一直等待
condition.await();
}
this.name = name;
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
this.gender = gender;
isEmpty = false;
// 资源池不为空了，修改标志位的值
condition.signalAll();
// notify()唤醒一个，notifyAll()唤醒所有，本程序中只有一个生产者和消费者对象，所以notify()和notifyAll()是一样的
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void pop() {
lock.lock();
try {
while (isEmpty) { // 当资源池为空时，pop()方法一直等待
condition.await();
}
System.out.print(this.name + " - ");
Thread.sleep(10);
// 使线程不安全的问题的暴露的更加明显
System.out.println(this.gender);
isEmpty = true;
// 资源被消费掉，资源池为空，重新设置标志位
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}}
}
输出：
春哥哥 - 男
凤姐 - 女
春哥哥 - 男
凤姐 - 女
春哥哥 - 男
小结：lock+标志位+await()+signalAll() 实现线程同步与线程通信，解决好了生产者与消费者问题
附： 其实我们只要用标志位（如上boolean isEmpty）控制，就可以控制线程的通信了，为什么还要加上wait()-notify()/notifyAll()或者lock+await()+signal()/signalAll()这样的东西呢？
代码a:
while (!isEmpty) { wait(); }
代码b:
while (!isEmpty);
从逻辑上讲，代码a和代码b是一样的，都是在等待isEmpty=true，才能跳出循环，区别在于代码a执行了wait()/condition.await()函数，这个函数使当前线程处于waiting()等待状态，JVM把当前线程存在对象等待池中，不占用cpu,不消耗系统资源；如果向代码b，当前线程处于running运行状态，占用Cpu，消耗系统资源。因为代码b使线程无论运行还是等待都处于running运行状态，过多的消耗系统资源，不利于程序执行；故我们的程序都写成的代码a的形式，线程通信中线程等待时，处于waiting状态，当然后果是要加上配套的notify()/notifyAll()或者condition.signal()/condition.signalAll()方法。
4.4 生产者-消费者问题：小结 从“生产者消费者问题”中，我们同时学习到线程同步和线程通信的知识，我们来总结一下，处理方式有两种，如下表：
| 线程同步 | 线程通信 | |
|---|---|---|
| 作用/用途 | 保证原子性操作 | 保证线程间执行顺序 |
| 组合：synchronized+标志位+wait()+notify()/notifyAll() | synchronized | 标志位+wait()+notify()/notifyAll() |
| 组合：lock+标志位+await()+signal()/signalAll() | lock机制 | 标志位+await()+signal()/signalAll() |
需求：汽车有“轿车”和“SUV”两种，都是“打蜡-抛光”反复操作，且看代码。
5.1 引子：打蜡抛光问题 代码——打蜡抛光问题：
package mypackage;
public class Test {
public static void main(String[] args) {
Car car = new Car();
new Thread(new WaxOn(car)).start();
new Thread(new WaxOff(car)).start();
}
}
// 共享资源类
class Car {
public void waxed(String name) { // 打蜡函数
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax On");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void buffed(String name) { // 抛光函数
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax Off");
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 打蜡类 生产者类
class WaxOn implements Runnable {
private Car car;
public WaxOn(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.waxed("小轿车");
} else {
car.waxed("SUV");
}
}
}
}
// 抛光类 消费者类
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.buffed("小轿车");
} else {
car.buffed("SUV");
}
}
}
}
输出：
小轿车 - 小轿车 - Wax Off
Wax On
SUV - SUV - Wax Off
小轿车 - Wax On
小轿车 - Wax Off
Wax On
SUV - SUV - Wax Off
Wax On
小轿车 - 小轿车 - Wax Off
Wax On
小结：出现两个问题，既没有实现 车型和 Wax 的对齐打印，也没有实现 0==i%2 的WaxOn和WaxOff交替打印，既没有实现线程同步，也没有实现线程通信，我们使用synchronized+标志位+wait()+notify()/notifyAll() 和 lock+标志位+await()+signal()/signalAll() 组合来解决这个问题，且看 5.2 5.3。
5.2 打蜡抛光问题：synchronized+标志位+wait()+notify()/notifyAll() 5.2.1 synchronized实现线程同步
代码：
package mypackage_synchronized;
public class Test {
public static void main(String[] args) {
Car car = new Car();
new Thread(new WaxOn(car)).start();
new Thread(new WaxOff(car)).start();
}
}
// 共享资源类
class Car {
public synchronized void waxed(String name) { // 打蜡函数
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax On");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void buffed(String name) { // 抛光函数
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax Off");
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 打蜡类 生产者类
class WaxOn implements Runnable {
private Car car;
public WaxOn(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.waxed("小轿车");
} else {
car.waxed("SUV");
}
}
}
}
// 抛光类 消费者类
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.buffed("小轿车");
} else {
car.buffed("SUV");
}
}
}
}
输出：
小轿车 - Wax On
SUV - Wax On
小轿车 - Wax On
SUV - Wax On
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax Off
小轿车 - Wax Off
SUV - Wax Off
小轿车 - Wax Off
小结：synchronized实现线程同步，原子性打印，所以 车型 和 Wax 对齐打印实现了，但是没有实现 线程通信，WaxOn和WaxOff交替打印，且看5.2.2 。
5.2.2 synchronize+标志位+wait()+notifyAll() 实现线程同步与线程通信
代码：
package mypackage_synchronized_wait_notify;
public class Test {
public static void main(String[] args) {
Car car = new Car();
new Thread(new WaxOn(car)).start();
new Thread(new WaxOff(car)).start();
}
}
// 共享资源类
class Car {
private boolean waxOn = false;
// 初始为未打蜡 线程通信控制变量
public synchronized void waxed(String name) { // 打蜡函数
try {
while (waxOn == true) // 当未抛光的时候 ,不断等待，直到抛光完成，结束等待，退出函数
wait();
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax On");
waxOn = true;
notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void buffed(String name) { // 抛光函数
try {
while (waxOn == false) // 当未打蜡的时候 ,不断等待，直到打蜡完成，结束等待，退出函数
wait();
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax Off");
waxOn = false;
notifyAll();
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 打蜡类 生产者类
class WaxOn implements Runnable {
private Car car;
public WaxOn(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.waxed("小轿车");
} else {
car.waxed("SUV");
}
}
}
}
// 抛光类 消费者类
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.buffed("小轿车");
} else {
car.buffed("SUV");
}
}
}
}
输出：
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax On
SUV - Wax Off
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax On
SUV - Wax Off
小轿车 - Wax On
小轿车 - Wax Off
小结：synchronize+wait()+notifyAll() 实现线程同步与线程通信，解决好了“汽车打蜡抛光”问题。我们可以尝试使用lock+await()+signalAll() 再实现一次，即更换一种方式实现“汽车打蜡抛光”问题，且看5.3.1 5.3.2。
5.3 打蜡抛光问题：lock+标志位+await()+signal()/signalAll() 5.3.1 使用lock实现线程同步
代码：
package mypackage_lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
Car car = new Car();
new Thread(new WaxOn(car)).start();
new Thread(new WaxOff(car)).start();
}
}
// 共享资源类
class Car {
private final Lock lock = new ReentrantLock();
public void waxed(String name) { // 打蜡函数
lock.lock();
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax On");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void buffed(String name) { // 抛光函数
lock.lock();
try {
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax Off");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
// 打蜡类 生产者类
class WaxOn implements Runnable {
private Car car;
public WaxOn(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.waxed("小轿车");
} else {
car.waxed("SUV");
}
}
}
}
// 抛光类 消费者类
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.buffed("小轿车");
} else {
car.buffed("SUV");
}
}
}
}
输出：
小轿车 - Wax On
SUV - Wax On
小轿车 - Wax On
SUV - Wax On
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax Off
小轿车 - Wax Off
SUV - Wax Off
小轿车 - Wax Off
小结：不会再出现车型---Wax对齐不上问题，因为waxed()和buffed()已经实现原子操作，但是还是没有实现0==i%2 交替打印，且看5.3.2 。
5.3.2 lock+标志位+await()+signalAll() 实现线程同步与线程通信
代码：
package mypackage_lock_await_signal;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
Car car = new Car();
new Thread(new WaxOn(car)).start();
new Thread(new WaxOff(car)).start();
}
}
// 共享资源类
class Car {
private boolean waxOn = false;
// 初始为未打蜡 线程通信控制变量
private final Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void waxed(String name) { // 打蜡函数
lock.lock();
try {
while (waxOn == true) // 当未抛光的时候 ,不断等待，直到抛光完成，结束等待，退出函数
condition.await();
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax On");
waxOn = true;
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void buffed(String name) { // 抛光函数
lock.lock();
try {
while (waxOn == false) // 当未打蜡的时候 ,不断等待，直到打蜡完成，结束等待，退出函数
condition.await();
System.out.print(name + " - ");
Thread.sleep(10);
System.out.println("Wax Off");
waxOn = false;
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
// 打蜡类 生产者类
class WaxOn implements Runnable {
private Car car;
public WaxOn(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.waxed("小轿车");
} else {
car.waxed("SUV");
}
}
}
}
// 抛光类 消费者类
class WaxOff implements Runnable {
private Car car;
public WaxOff(Car car) {
this.car = car;
}
@Override
public void run() {
for (int i = 0;
i < 5;
i++) {
if (0 == i % 2) {
car.buffed("小轿车");
} else {
car.buffed("SUV");
}
}
}
}
输出5：
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax On
SUV - Wax Off
小轿车 - Wax On
小轿车 - Wax Off
SUV - Wax On
SUV - Wax Off
小轿车 - Wax On
小轿车 - Wax Off
小结：lock+await()+signalAll() 实现线程同步与线程通信，解决好了“汽车打蜡抛光”问题
5.4 打蜡抛光问题：小结 本文的“打蜡抛光”问题和“生产者--消费者”问题非常相似，或者可以说是同一问题，即使用synchronized+标志位+wait()+notify()/notifyAll()或者lock+标志位+await()+signal()/signalAll()，实现线程同步+线程通信。
六、线程同步+线程通信应用之三：哲学家就餐问题 6.1 从死锁问题到哲学家就餐问题 6.1.1 死锁问题
（1）死锁定义：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
（2）死锁问题的四个条件：
互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意：这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立。
Java语言中，因为Java在设计时，JVM不检测也不试图避免这种情况,所以死锁无法在语言层上得到根本性解决,只能由程序员每次写程序时注意避免。
6.1.2 死锁经典问题——哲学家进餐问题
下面开始介绍死锁的经典问题——哲学家进餐问题：
有五个哲学家，他们的生活方式是交替地进行思考和进餐，哲学家们共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，平时哲学家进行思考，饥饿时便试图取其左、右最靠近他的筷子，只有在他拿到两支筷子时才能进餐，该哲学家进餐完毕后，放下左右两只筷子又继续思考。
文章图片
image.png 约束条件：
(1)只有拿到两只筷子时，哲学家才能吃饭。
(2)如果筷子已被别人拿走，则必须等别人吃完之后才能拿到筷子。
(3)任一哲学家在自己未拿到两只筷子吃完饭前，不会放下手中已经拿到的筷子
解决方法：
哲学家进餐问题特点：每个哲学既是消费者（拿起左右两只筷子） 又是生产者（放下左右两只筷子） （这就是哲学家就餐问题与之前的生产者-消费者问题不同之处）
只要使用synchronized 或者lock 将 "拿起左右两只筷子"和“放下左右两只筷子” 封装为原子操作，再使用 wait()--notifyAll() 或者 await()--signalAll() 实现哲学家之间（生产者消费者之间）的通信，整个问题就解决。
两种方式： synchronized+wait()+notifyAll() 和 lock+await()+signalAll()
本文给出两种哲学家进餐问题的解决方案，且看6.2 6.3。
6.2 哲学家就餐问题：synchronized+标志位+wait()+notify()/notifyAll() 代码——synchronize+wait()+notifyAll() 实现哲学家就餐问题：
package mypackage_synchronized_wati_notify;
//哲学家就餐问题解决每个哲学既是消费者（拿起左右两只筷子）又是消费者（放下左右两只筷子）
//只要使用synchronized 或者lock将 "拿起左右两只筷子"和“放下左右两只筷子” 封装为原子操作
//再使用 wait()--notifyAll() 或者await()--signalAll()实现哲学家之间（生产者消费者之间）的通信整个问题就解决了
//所有两种方式synchronized+wait()+notifyAll()和lock+await()+signalAll()
public class Test {
public static void main(String[] args) {
Chopsticks fork = new Chopsticks();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
}
}
class Philosopher implements Runnable { // 既是生产者又是消费者
private Chopsticks _chopsticks;
public Philosopher(Chopsticks _chopsticks) {
this._chopsticks = _chopsticks;
}
@Override
public void run() {
while (true) {
thinking();
// eating 是关键代码 eating之前要锁住筷子 eating之后释放筷子
{
_chopsticks.lockChopSticks();
eating();
_chopsticks.unlockChopSticks();
}
}
}
public void eating() {
System.out.println("Number : " + Thread.currentThread().getName() + " Eating!");
try {
Thread.sleep(1000);
// 模拟吃饭，占用一段时间资源
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void thinking() {
System.out.println("Number : " + Thread.currentThread().getName() + " Thinking!");
try {
Thread.sleep(1000);
// 模拟思考
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Chopsticks {
private boolean[] _islock = { false, false, false, false, false, false };
// 一共五个筷子，使用时被锁住，默认都是没有被锁住的
public synchronized void lockChopSticks() {
String name = Thread.currentThread().getName();
int i = Integer.parseInt(name.substring(name.length() - 1, name.length()));
// i用于数组
while (_islock[i] || _islock[(i + 1) % 5]) {
try {
wait();
// 如果左右手有一只正被使用，等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
_islock[i] = true;
_islock[(i + 1) % 5] = true;
}
public synchronized void unlockChopSticks() {
String name = Thread.currentThread().getName();
int i = Integer.parseInt(name.substring(name.length() - 1, name.length()));
// i用于数组
_islock[i] = false;
_islock[(i + 1) % 5] = false;
notifyAll();
// 唤醒其他线程
}
}
输出：
Number : Thread-1 Thinking!
Number : Thread-2 Thinking!
Number : Thread-3 Thinking!
Number : Thread-0 Thinking!
Number : Thread-4 Thinking!
Number : Thread-0 Eating!
Number : Thread-2 Eating!
Number : Thread-0 Thinking!
Number : Thread-3 Eating!
Number : Thread-1 Eating!
Number : Thread-2 Thinking!
Number : Thread-1 Thinking!
Number : Thread-2 Eating!
Number : Thread-3 Thinking!
Number : Thread-0 Eating!
小结：synchronize+标志位数组+wait()+notifyAll() 实现线程同步和线程通信，完美的解决了哲学家进餐问题，下面我们再尝试使用lock+await()+signalAll() 实现哲学家进餐问题，且看代码6.3 。
6.3 哲学家进餐问题：lock+标志位+await()+signal()/signalAll() 代码——lock+await()+signalAll() 实现哲学家就餐问题：
package mypackage_lock_await_signal;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//哲学家就餐问题解决每个哲学既是消费者（拿起左右两只筷子）又是消费者（放下左右两只筷子）
//只要使用synchronized 或者lock将 "拿起左右两只筷子"和“放下左右两只筷子” 封装为原子操作
//再使用 wait()--notifyAll() 或者await()--signalAll()实现哲学家之间（生产者消费者之间）的通信整个问题就解决了
//所有两种方式synchronized+wait()+notifyAll()和lock+await()+signalAll()
public class Test {
public static void main(String[] args) {
Chopsticks fork = new Chopsticks();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
new Thread(new Philosopher(fork)).start();
}
}
class Philosopher implements Runnable { // 既是生产者又是消费者
private Chopsticks _chopsticks;
public Philosopher(Chopsticks _chopsticks) {
this._chopsticks = _chopsticks;
}
@Override
public void run() {
while (true) {
thinking();
// eating 是关键代码 eating之前要锁住筷子 eating之后释放筷子
{
_chopsticks.lockChopSticks();
eating();
_chopsticks.unlockChopSticks();
}
}
}
public void eating() {
System.out.println("Number : " + Thread.currentThread().getName() + " Eating!");
try {
Thread.sleep(1000);
// 模拟吃饭，占用一段时间资源
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void thinking() {
System.out.println("Number : " + Thread.currentThread().getName() + " Thinking!");
try {
Thread.sleep(1000);
// 模拟思考
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Chopsticks {
private final Lock lock=new ReentrantLock();
private Condition condition=lock.newCondition();
private boolean[] _islock = { false, false, false, false, false };
// 一共五个筷子，使用时被锁住，默认都是没有被锁住的
publicvoid lockChopSticks() {
lock.lock();
String name = Thread.currentThread().getName();
int i = Integer.parseInt(name.substring(name.length() - 1, name.length()));
// i用于数组
while (_islock[i] || _islock[(i + 1) % 5]) {
try {
condition.await();
// 如果左右手有一只正被使用，等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
_islock[i] = true;
_islock[(i + 1) % 5] = true;
lock.unlock();
}
publicvoid unlockChopSticks() {
lock.lock();
String name = Thread.currentThread().getName();
int i = Integer.parseInt(name.substring(name.length() - 1, name.length()));
// i用于数组
_islock[i] = false;
_islock[(i + 1) % 5] = false;
condition.signalAll();
lock.unlock();
}
}
输出：
Number : Thread-1 Thinking!
Number : Thread-4 Thinking!
Number : Thread-2 Thinking!
Number : Thread-3 Thinking!
Number : Thread-0 Thinking!
Number : Thread-2 Eating!
Number : Thread-4 Eating!
Number : Thread-4 Thinking!
Number : Thread-2 Thinking!
Number : Thread-1 Eating!
Number : Thread-3 Eating!
Number : Thread-3 Thinking!
Number : Thread-2 Eating!
Number : Thread-1 Thinking!
Number : Thread-0 Eating!
小结：同样地，使用lock+标志位数组+await()+signalAll() 实现线程同步和线程通信，也可以完美的解决了哲学家进餐问题。
6.4 哲学家就餐问题：小结 哲学家就餐问题之小结：
每个哲学既是消费者（拿起左右两只筷子），又是生产者（放下左右两只筷子）；
第一，只要使用synchronized 或者lock ， 将 "拿起左右两只筷子"和“放下左右两只筷子” 封装为原子操作；
第二，再使用 wait()--notifyAll() 或者 await()--signalAll() ，实现哲学家之间（生产者消费者之间）的通信， 整个问题就解决了。
七、小结 本文介绍Java多线程技术，分为五个部分：
多线程的两种实现方式——继承Thread类和实现Runnable接口；
线程同步应用：三人吃苹果；
线程同步+线程通信应用之一：生产者-消费者问题；
线程同步+线程通信应用之二：打蜡抛光问题；
线程同步+线程通信之用之三：哲学家就餐问题。
可以帮助初学者的Java多线程入门。
天天大码，天天进步！
推荐阅读
- JAVA（抽象类与接口的区别&重载与重写&内存泄漏）
- 宽容谁
- 我要做大厨
- 增长黑客的海盗法则
- 画画吗（）
- 2019-02-13——今天谈梦想（）
- 远去的风筝
- 三十年后的广场舞大爷
- 叙述作文
- 20190302|20190302 复盘翻盘