【Java并发002】使用层面：线程同步与线程通信全解析

2020-11-01 本文已影响0人毛毛的学习笔记

一、前言

本文介绍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 ComputerGame  0
Listening Music  0
Playing ComputerGame  1
Listening Music  1
Playing ComputerGame  2
Listening Music  2

注意：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 Music  0
Playing ComputerGame  0
Chating in QQ  0
Listening Music  1
Playing ComputerGame  1
Chating in QQ  1
Listening Music  2
Playing ComputerGame  2
Chating in QQ  2

相对上面，扩展了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 ComputerGame  0
Chating in QQ  0
Listening Music  0
Listening Music  1
Playing ComputerGame  1
Chating in QQ  1
Listening Music  2
Chating in QQ  2
Playing ComputerGame  2

这里通过实现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 Music  0
Playing ComputerGame  0
Chating in QQ  0
Listening Music  1
Playing ComputerGame  1
Chating in QQ  1
Listening Music  2
Playing ComputerGame  2
Chating in QQ  2

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 Music  0
Playing ComputerGame  0
Chating in QQ  0
Playing ComputerGame  1
Chating in QQ  1
Listening Music  1
Chating in QQ  2
Playing ComputerGame  2
Listening Music  2

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;
    private  final 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 实现方式一：生产者将生产的产品直接交给消费者消费

实现方式一代码：

//生产者
class  Producer{
     private  Consumer  con;//消费者对象
}
//消费者
class  Consumer{
     private  Producer  pro;//消费者对象
}

该代码使用双向注入，将消费者引用注入

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 };// 一共五个筷子，使用时被锁住，默认都是没有被锁住的
    public  void 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();
    }
    public  void 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并发002】使用层面：线程同步与线程通信全解析

一、前言

二、初识多线程

2.1 引子：小明一边玩游戏一边听音乐

2.2 实现多线程的两种方式

2.2.1 继承Thread类：扩展——小明一边玩游戏一边听音乐，还一边用QQ和小强聊天

2.2.2 实现Runnable接口

2.3 实现多线程的两种方式（匿名方式）

2.3.1 继承Thread类（匿名内部类）

2.3.2 实现Runnable接口（匿名内部类）

2.4 小结

三、线程同步

3.1 引子：三人吃苹果问题

3.1.1 继承Thread类：三人吃苹果问题

3.1.2 实现Runnable接口：三人吃苹果问题

3.1.3 加上Thread.sleep(毫秒数)

3.2 线程同步——三人吃苹果问题解决

3.2.1 代码——同步代码块

3.2.2 代码——同步方法

3.2.3 代码——lock锁机制

3.3 小结

四、线程同步+线程通信应用之一：生产者-消费者问题

4.1 实现线程通信的两种方式

4.1.1 实现方式一：生产者将生产的产品直接交给消费者消费

4.1.2 实现方式二：单独设置一个共享资源类，生产者类生产的产品放入共享资源中，消费者类从共享资源中取出消费

4.2 生产者-消费者问题：synchronized+标志位+wait()+notify()/notifyAll()

4.2.1 使用synchronized实现线程同步

4.2.3 synchronize+标志位+wait()+notifyAll() 实现线程同步与线程通信

4.3 生产者-消费者问题：lock+标志位+await()+signal()/signalAll()

4.3.1 使用lock实现线程同步

4.3.2 lock+标志位+await()+signalAll() 实现线程同步与线程通信

4.4 生产者-消费者问题：小结

五、线程同步+线程通信应用之二：打蜡抛光问题

5.1 引子：打蜡抛光问题

5.2 打蜡抛光问题：synchronized+标志位+wait()+notify()/notifyAll()

5.2.1 synchronized实现线程同步

5.2.2 synchronize+标志位+wait()+notifyAll() 实现线程同步与线程通信

5.3 打蜡抛光问题：lock+标志位+await()+signal()/signalAll()

5.3.1 使用lock实现线程同步

5.3.2 lock+标志位+await()+signalAll() 实现线程同步与线程通信

5.4 打蜡抛光问题：小结

六、线程同步+线程通信应用之三：哲学家就餐问题

6.1 从死锁问题到哲学家就餐问题

6.1.1 死锁问题

6.1.2 死锁经典问题——哲学家进餐问题

6.2 哲学家就餐问题：synchronized+标志位+wait()+notify()/notifyAll()

6.3 哲学家进餐问题：lock+标志位+await()+signal()/signalAll()

6.4 哲学家就餐问题：小结

七、小结

猜你喜欢

热点阅读