带你了解Java高级编程-----多线程

带你了解Java高级编程-----多线程

对于Java的学习，基本的步骤是Java基础编程，掌握了Java语言的基本语法、数组、面向对象编程、异常处理这四部分之后，就要开始对Java高级编程进一步学习
tips：Java高级编程，是以Java基础编程为基础，是进一步的延申。

---

这篇文章主要是针对Java高级编程中的----多线程。

---

多线程

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、简单了解什么是多线程？

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

  有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。通过对多线程的使用，可以编写出非常高效的程序。
  不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。
  请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

多线程程序的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率。
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

使用多线程的情况：

1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3.需要一些后台运行的程序时。

二、线程相关的基本概念

1.程序（program）

程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象

2.进程（process）

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

		如：运行中的QQ，运行中的MP3播放器
        程序是静态的，进程是动态的
		进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

【我们可以在任务管理器中查看自己电脑点相关进程。】

3.线程（thread）

进程可进一步细化为线程，是一个程序内部的一条执行路径。
①若一个进程同一时间并行执行多个线程，就是支持多线程的。
②线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
③一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。
这就使得线程间通信更简便、高效。但多个线程操作共享的系统源可能就会带来安全的隐患。

---

4.CPU（并行与并发）

（1）单核、多核CPU理解：

①单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。
②多核CPU的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

（2）并行、并发：

①并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
②并发：一个CPU(采用时间片)同时执行多个任务。比如：多个人做同一件事。

三、线程的创建和使用

1.线程的创建

创建新执行线程有四种方法：
(1)继承Thread类的方式;
(2)实现Runnable接口的方式;
(3)实现Callable接口，Future的方式;
(4)线程池;

(1)继承Thread类的方式：

Thread类的特性
①每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
②通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。

/**
 * 多线程的创建 ：
 *      方式一：继承thread类
 *       1.创建一个继承于Thread类的子类
 *       2.重写thread类的run()               ----> 将此线程执行的操作声明放在run()中
 *       3.创建按thread类的子类的对象
 *       4.通过此对象调用start()
 */

//1.创建继承thread的类
class MyThread extends Thread {
    //2.重写run()方法
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //3.创建thread类的子类对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start()
        t1.start();
/*
 * 在主线程中运行顺序不确定
 */
        for (int i=0; i< 100; i++){
            if(i % 2 == 0){
                System.out.println("-------------------");
            }
        }
    }
}

上述代码的运行结果“------------------” 和 偶数 混合出现【在主线程的运行顺序是不确定的】

(2)实现Runnable接口的方式：

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建一个实现类的对象
 * 4.将此对象最为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用Start()
 */

//1.创建一个实现Runnable接口的类
class MThread implements Runnable{
    //实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + " : " + i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建一个实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程一");
        //5.通过Thread类的对象调用start() ①启动线程 ②调用当前线程的run() -->调用了Runnable类型的target
        t1.start();

        //创建另一个线程
        Thread t2 = new Thread(mThread);
        t2.setName("线程二");
        t2.start();
    }
}

简而言之，在实现Runnable的接口后，需要借用Thread的构造器进行创建Thread类。

---

前两种方式的比较：
①这两种创建线程的方式实际上都是利用了Thread类。【同】
②线程要实现的方法都要重写run()方法，通过run()方法实现。【同】
③继承Thread：线程代码存放Thread子类run方法中。【异】
④实现Runnable：线程代码存在接口的子类的run方法。【异】
⑤实现Runnable类的优势：避免了单继承的局限性；多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

---

【总结】：我们弄懂了接口和继承，就不难理解Thread和Runnable。
在刚接触的时候可能会有些迷糊这二者的区别于联系，但是实践和总结过后我们会发现这是两个完全不同的实现多线程，
一是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。
其实，在实现一个任务用多个线程来做也可以用继承Thread类来实现，只是比较麻烦，一般我们用实现Runnable接口来实现。

(3)实现Callable接口，Future的方式：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/
**
 * 创建线程的方式三 : 实现Callable接口。    -----JDK 5.0新增
 *
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1.call()可以有返回值的。
 * 2.call()可以抛出异常
 * 3.Callable 是支持泛型的
 */

//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer>{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get() 返回值即为FutureTask构造器参数Callable实现类重写的coll()的返回值
            Integer o = futureTask.get();
            System.out.println("总和为 ： " + o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

与使用Runnable相比， Callable功能更强大些。
①可以有返回值；【call()方法】
②能够抛出异常；【call()方法】
③能够支持泛型

(4) 使用线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
 *
 * 好处 ：
 *  提高响应速度（减少了创建新线程的时间）；
 *  降低资源消耗（重复利用线程池中线程，不需要每次都创建）；
 *  便于线程管理；
 *       corePoolSize：核心池的大小
 *       maximumPoolSize：最大线程数
 *       keepAliveTime：线程没有任务时最多保持多长时间后会终止
 *
 */

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {

        //1.提供指定线程数量的线程池(此处指定了10个)
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;

        //设置线程池的属性
        System.out.println(executorService.getClass());

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        executorService.execute(new NumberThread());  //适合适用于Runnable
        executorService.execute(new NumberThread1()); //适合适用于Runnable
        //executorService.submit( Callable callable);  //适合使用于Callable

        //3.关闭连接池
        executorService.shutdown();
    }
}

2.Thread类的相关的方法

下表列出了Thread类的一些重要方法:

测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法:

还有两个不推荐使用的方法：

方法	方法详情
stop()	强制线程生命期结束，不推荐使用
boolean isAlive()	返回boolean，判断线程是否还活着

3.线程的调度

计算机通常只有一个CPU，在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令。所谓多线程的并发运行，其实是指从宏观上看，各个线程轮流获得CPU的使用权，分别执行各自的任务。在运行池中，会有多个处于就绪状态的线程在等待CPU，JAVA虚拟机的一项任务就是负责线程的调度，线程调度是指按照特定机制为多个线程分配CPU的使用权。

有两种调度模型：分时调度模型和抢占式调度模型。

4.线程的优先级

每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是
      1 （Thread.MIN_PRIORITY ） - 10（Thread.MAX_PRIORITY ）;
  默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

/**
 * 【线程的优先级】：(线程优先级是一个概率事件)
 * 1.
 * MAX_PRIORITY : 10
 * MIN_PRIORITY : 1
 * NORM_PRIORITY : 5   -->默认的线程优先级
 * 2.如何获取和设置当前线程的优先级：
 * getPriority() : 获取线程的优先级
 * setPriority(int p) : 设置线程的优先级
 *
 * 【说明：高优先级的线程要抢占低优先级线程cpu的执行权，但只是从概率上讲,高优先级的线程高概率的情况下被执行
 *      并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行】
 */

class ThreadPriority extends Thread{
    @Override
    public void run() {
        for (int i = 0; i< 100; i++){
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ">>" + Thread.currentThread().getPriority() + " : " + i);
            }

        }
    }
}
public class ThreadPriorityTest {
    public static void main(String[] args) {
        ThreadPriority p1 = new ThreadPriority();

        //设置分线程的优先级
        p1.setPriority(Thread.MAX_PRIORITY);
        p1.setName("高优先级");

        p1.start();

        //给主线程命名
        Thread.currentThread().setName("低优先级");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i< 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ">>" + Thread.currentThread().getPriority() + " : " + i);
            }
        }
    }
}

【说明】：优先级的高低确定了线程抢夺cpu的执行权，但优先级归根结底是一个概率事件,只能说高优先级的更容易被cup先执行。

5.线程的分类

Java中的线程分为两类：

一种是守护线程，一种是用户线程。

1. 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
2. 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
3. Java垃圾回收就是一个典型的守护线程。
4. 若JVM中都是守护线程，当前JVM将退出。
5. 形象理解：兔死狗烹，鸟尽弓藏 (比喻事情成功后，把出过力的人抛弃或杀死。)

三、线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

• 新建：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

• 就绪：当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

• 运行：如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

• 阻塞：如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

  (1)等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
  (2)同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
  (3)其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当 sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

• 死亡 ：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
  

四、线程的同步

1.窗口售票：

在说明线程的同步问题前，大家先看一下经典的例题：模拟火车站售票程序，开启三个窗口售票。

/**
 *模拟火车站售票程序，开启三个窗口售票
 *
 * @Author duokanzhouzhou
 * @Create 2021/7/17
 */
public class WindowTestO {
    public static void main(String[] args) {
        Windows w1 = new Windows();
        Windows w2 = new Windows();
        Windows w3 = new Windows();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Windows extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if (ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName() + "卖票，窗口为：----> " + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

按照上面通过继承Thread类来实现的解决方案，在运行出来的结果是三个窗口都卖出了100张票，而且代码中的Thread.sleep(100)；在运行中并没有体现出来。
但实际，应该是一共一百张票，三个窗口不能够拥有重复。

1. 多线程出现了安全问题

2. 问题的原因：
   当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

3. 解决办法：
   对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

    为了解决以上代码存在的不足，我们引入线程同步机制
    Java对于多线程的安全问题提供了专业的解决方式：同步机制
   

2.同步机制：

Synchronized的使用：

1. 同步代码块：
   synchronized (对象){
   // 需要被同步的代码；
   }

2. synchronized还可以放在方法声明中，表示整个方法为同步方法。 例如： public synchronized void show (String name){ …. }

我们做如下优化：

/**
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 *
 *
 * 说明 : 在继承Thread类创建多线程的方式中，慎用this同步监视器
 *
 */

public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window extends Thread{

    private static int ticket = 100;
    //private static Object obj = new Object(); //方法一1.1
    @Override
    public void run() {
        while (true){
            //synchronized (obj){   //方法1.2
            //简单方式，类也是对象【Window.class运行过程中只运行了一次】 //方法2
            synchronized (Window.class){
                //错误方式 ： synchronized(this)，this 代表着w1,w2,w3
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":买票，票号为 --》" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

使用synchronized时，要格外注意同步监视器的使用。
使用synchronized时，要格外被同步的代码的范围。
在继承Thread类创建多线程的方式中，慎用this同步监视器。

下面是实现Runnable接口的synchronized的使用

public class WindowTest2{
    public static void main(String[] args) {
        Window2 w2 = new Window2();

        Thread t1 = new Thread(w2);
        Thread t2 = new Thread(w2);
        Thread t3 = new Thread(w2);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{

    private int ticket = 100;

    //Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            //synchronized(obj)
            //最近但的同步监视器，this,当前对象
            synchronized (this) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖票，票号为 : " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

在实现Runnable接口的方式下，可以使用this同步监视器

下面是使用同步方法，以实现Runnable接口来举例，继承Thread的方式与之相同就不多加赘述。

class Window3 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }
    //同步方法
    private synchronized void show(){
        //synchronized (this) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 买票，票号为 : " + ticket);
                ticket--;
            }
        //}
    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w3 = new Window3();

        Thread t1 = new Thread(w3);
        Thread t2 = new Thread(w3);
        Thread t3 = new Thread(w3);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

3.锁

（1）. 释放锁的操作

• 当前线程的同步方法、同步代码块执行结束。
• 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、
  该方法的继续执行。
• 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导
  致异常结束。
• 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线
  程暂停，并释放锁。

（2）. 不释放锁的操作

• 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
• 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
  *>应尽量避免使用suspend()和resume()来控制线程。

（3）.死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁；
• 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
  阻塞状态，无法继续
• 解决方法
  ①专门的算法、原则
  ②尽量减少同步资源的定义
  ③尽量避免嵌套同步

4.Lock锁

ReentrantLock 类实现了 Lock ，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

3. Lock(锁)
   class A{
   private final ReentrantLock lock = new ReenTrantLock();
   public void m(){
   lock.lock();
   try{
   //保证线程安全的代码; }
   finally{
   lock.unlock();
   } } }
   注意：如果同步代码有异常，要将unlock()写入finally语句块

public class LockTest {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread thread1 = new Thread(window2);
        Thread thread2 = new Thread(window2);
        Thread thread3 = new Thread(window2);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}


class Window2 implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);//写入true则为公平（先进先出原则）;写入false则为不公平（）
    @Override
    public void run() {
        while (true) {
            try {
                //2.调用lock()【上锁】
                lock.lock();
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + " : " + "售票，票号为-->" + ticket);
                    ticket--;
                }else {
                    break;
                }
            } finally {
                //3.调用unlock()【解锁】
                lock.unlock();
            }
        }
    }
}

---

【说明】：
方式一：同步代码块
1.操作共享数据代码，即需要被同步的代码 ---->不能多或少包含代码
2.共享数据：多个线程共同操作的数据 3.同步监视器，俗称：‘锁’，任何一个类的对象，都可以充当锁。(多线程必须同用一把锁)】 (补充 ： 在世先Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器)
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明同步：
解决看线程的安全问题 ----好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 —坏处
方式三：Lock锁
Lock需要手动的启动同步（Lock()）,同时结束同步也需要手动的实现（unlock()）
Lock —> 同步代码块（已经进入了方法体，分配了相应资源） —> 同步方法（在方法体之外）

---

五、线程的通信

我们经常说线程之间的通信,线程之间的协作,但是根据他的应用场景其实是很容易搞清楚的;

• 比如说:

生产者-消费者,又比如说队列,等等的Demo,

• 从日常生活的角度来说:

去超市购物,你是消费者,你没有钱,就要等有钱才能买；超市没有货物,那你就等超市有货物再买。

这种相互等待的过程,就是线程之间通信的过程,也就是协作的过程,那么从以下两个角度或者更多的角度去解决这个问题,并且说明一些关键字的介绍。

我们可以通过实例来进一步了解：
使用两个线程打印 1-100。线程1, 线程2 交替打印

/**
 * 涉及到的三个方法：
 * wait() : 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
 * notify() : 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级最高的那个
 * notifyAll() : 一旦执行此方法，就会唤醒所有被wait的一个线程
 *
 * 说明：
 * 1.wait() notify()  notifyAll() 三个方法必须使用在同步代码块 或 同步方法中。
 * 2.wait() notify()  notifyAll() 三个方法必须是同步代码块 或 同步方法中的同步监视器。
 *      否则，会出现IllegalMonitorStateException异常
 * 3.wait() notify()  notifyAll() 三个方法是定义在java.lang.Object类中。
 *
 */
class Number implements Runnable{
    private int number = 1;

    @Override
    public void run() {
        while (true){
            synchronized (this) {

                this.notify();//唤醒notify() 与 wait()一起使用

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (number <= 100){
                    System.out.println(Thread.currentThread().getName() + " : " + number);
                    number++;
                    //是的调用如下wait()方法的线程进入阻塞状态
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number n = new Number();

        Thread t1 = new Thread(n);
        Thread t2 = new Thread(n);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

sleep() 和 wait()的异同？

1.相同点：一旦执行方法，都可以是当前的线程进入阻塞状态

2.不同点：

1. 两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
2. 调用的要求不同:sleep()可以在任何需要的场景下调用。wait() 必须使用在同步代码块或同步方法中
3. 关于是否释放同步监视器：sleep()不会释放锁，wait()会释放锁

---

上图的代码中，同步监视器为this,所以wait() 和 notify（）也使用this,【书写是可省略】// 若不是this,则进行书写时不能省略。

---

六、关于线程通讯的经典例题

生产者/消费者问题:

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
　　这里可能出现两个问题：
　　　　生产者比消费者快时，消费者会漏掉一些数据没有取到。
　　　　消费者比生产者快时，消费者会取相同的数据。

编写生产者消费者多线程程序，设有一个最大库存量为4的电视机仓库，生产10台电视机，一边生产一边销售（消费）。

---

以上内容便是对Java高级编程----多线程部分的讲解，如有错误，欢迎指正。
如果对你有帮助，欢迎关注点赞加收藏哦!!!。

---