Java中的线程

最新推荐文章于 2024-08-15 23:35:35 发布

Eternal_Summer-

最新推荐文章于 2024-08-15 23:35:35 发布

阅读量1.6k

点赞数 9

分类专栏： java SE 文章标签：多线程 java 编程语言

本文链接：https://blog.csdn.net/qq_42278320/article/details/115741920

版权

java 同时被 2 个专栏收录

27 篇文章 0 订阅

订阅专栏

2 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的线程概念，包括进程与线程的区别、单线程与多线程、线程的创建（Thread派生和Runnable实现）、线程优先级、线程生存周期以及线程同步。通过卖票案例展示了线程安全问题，并通过同步代码块、同步方法和Lock锁进行了解决方案的探讨。此外，还提到了生产者消费者模式在多线程协作中的应用。

摘要由CSDN通过智能技术生成

Java中的线程

1. 引入

1.1. 进程和线程

进程：
1. 是正在运行的程序。比如在Windows系统中，一个运行的exe就是一个进程。
2. 是系统进行资源分配和调度的独立单位
3. 每一个进程都有它自己的内存空间和系统资源
线程：
1. 是进程中的单个顺序控制流，是一条执行的路径。
2. 线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。
3. 是CPU调度和分派的最小单位。
4. 一个程序至少有一个进程，一个进程至少有一个线程。

1.2. 单线程和多线程

单线程：一个进程如果只有一条执行路径，则称为单线程程序
1. 单线程程序演示
多线程：一个进程如果有多条执行路径，则称为多线程程序
1. 多线程程序演示

注：在线程之间实际上是”轮流“执行的，而并非是”同时“执行的。

2. Java中的线程——Thread

2.1. 涉及总览

Java中的线程基础内容讲解
Java中线程的两种创建方式
- Thread 类进行派生并覆盖 run方法
- 实现Runnable接口创建线程
线程优先级
线程生存周期【重点理解】
Java中的多线程在实际中的应用----卖票案例
卖票案例中存在的问题分析
同步代码块解决多线程中数据安全的问题
同步方法解决数据安全问题
Lock锁
生产者和消费者模式----多线程协作问题

2.2. Java中的线程基础内容讲解

 在Java中，“线程”指两件不同的事情：
 1、java.lang.Thread类的一个实例；
 2、线程的执行。
   在 Java程序中，有两种方法创建线程：
    	一是对 Thread 类进行派生并覆盖 run方法；
        二是通过实现Runnable接口创建。
        使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。
        一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。
        Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。
        一个Java应用总是从main()方法开始运行，main()方法运行在一个线程内，他被称为主线程。
        一旦创建一个新的线程，就产生一个新的调用栈。
        线程总体分两类：用户线程和守候线程。
        守护线程：守护线程的唯一用途就是为其他线程提供服务。
        当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。

2.3. Java中线程的两种创建方式

2.3.1. Thread 类进行派生并覆盖 run方法

package com.itlearn.threads;

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<100;i++){
            System.out.println("MyThread->"+i);
        }
    }
}

可见：创建MyThread.java类，并继承Thread（java.lang.Thread）,并重写run方法。即完成了MyThread线程的创建。

下面介绍两种方法：

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

public class ThreadsDemo {
    public static void main(String[] args) {
        Thread thread1 = new MyThread();
        thread1.start();
    }
}

run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

也就是说，如果想启动一个线程，那么直接调用该线程的run方法是无效的，应该调用start方法，由虚拟机调用run方法。

那么为什么要重写父类run方法？

因为我们的MyThread类中可能还存在其他的代码，但不是所有的代码都需要被线程所执行，为了区分哪些代码是需要被线程执行的，Java提供了run方法来封装需要被线程执行的方法。

2.3.2. 实现Runnable接口创建线程

package com.itlearn.threads;

public class MyThread_Runnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0;i<100;i++){
            System.out.println("MyThread_Runnable->"+i);
        }
    }
}

可见：我们创建了MyThread_Runnable.java类，并实现了Runnable接口，所以必须实现该接口的方法，而该接口只有一个方法，即run()。我们在run()方法中可以部署我们的业务代码。

那么我们如何启动该线程呢？

首先介绍Thread类的两个构造方法

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象，并指定该线程名称

直接上代码：

public class ThreadsDemo {
    public static void main(String[] args) {
        //创建myThread_runnable对象
        MyThread_Runnable myThread_runnable = new MyThread_Runnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        Thread thread2 = new Thread(myThread_runnable);
        thread2.start();
    }
}

可得出实现步骤如下：

- 定义一个类MyThread_Runnable实现Runnable接口
- 在MyThread_Runnable类中重写run()方法
- 创建MyThread_Runnable类的对象
- 创建Thread类的对象，把MyThread_Runnable对象作为构造方法的参数
- 启动线程

注：在实际应用中，我们推荐使用实现Runnable接口的方式创建线程。

理由：

避免了Java单继承的局限性
适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

3. 线程优先级

3.1. 优先级引入

在Java中是支持多线程的，那么引发的问题就是：如果由多个线程，都要通过CPU的调度，那么调度的优先级是怎样的呢？即：这么多线程，谁优先执行谁后执行呢？在搞清楚这个问题之前我们必须明白线程的调度方式。

3.2. 线程调度

两种调度方式：

分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

注：Java使用的是抢占式调度模式

调度随机性：

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

2.4.3. 线程优先级方法

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

2.4.4. 抢占式和随机性验证

抢占式+随机性验证：

package com.itlearn.threads;

public class ThreadsDemo {
    public static void main(String[] args) {
        Thread thread1 = new MyThread();
        MyThread_Runnable myThread_runnable = new MyThread_Runnable();
        Thread thread2 = new Thread(myThread_runnable);
        
        thread1.start();
        thread2.start();
    }
}

即：将我们创建的两个线程同时启动。可见运行结果

在这里插入图片描述

即：两个线程并不是依次执行，而是在抢占CPU的资源，就是执行权，谁抢到了谁就执行。

下面我们设置线程优先级，再次运行

package com.itlearn.threads;

public class ThreadsDemo {
    public static void main(String[] args) {
        Thread thread1 = new MyThread();
        MyThread_Runnable myThread_runnable = new MyThread_Runnable();
        Thread thread2 = new Thread(myThread_runnable);

        //获得线程当前优先级
        System.out.println("Thread1->"+thread1.getPriority());
        System.out.println("Thread2->"+thread1.getPriority());
        //设置线程优先级
        thread1.setPriority(4);
        thread2.setPriority(6);

        thread1.start();
        thread2.start();
    }
}

在这里插入图片描述

结论：一个线程的优先级高，仅代表该线程获得CPU时间片的几率高，而并非是一定优先执行!

4. 线程生存周期【重点理解】

直接上图：

在这里插入图片描述

4.1. 线程的6种状态

New（新建）
Runnable（可运行）
Blocked（阻塞）
Waiting（等待）
Timed Waiting（计时等待）
Terminated（终止）

4.1.1. 新建线程

当用new操作符创建一个新线程时，如new Thread®,这个线程还没有开始运行。这意味着它的状态是新建（New），当一个线程处于新建状态时，程序还没有运行线程中的代码。

4.1.2. 可运行线程

一旦调用start方法，线程就处于可运行（Runnable）状态。一个可运行的线程也可能没有运行。要由操作系统为线程提供具体的运行时间。注意：Java规范没有将正在运行作为一个单独的状态。一个正在运行的线程仍然储于可运行状态。

线程调度的细节依赖于操作系统提供的服务，抢占式调度系统给每一个可运行的线程一个时间片来执行任务。当时间片用完时，操作系统会剥夺该线程的运行权，并给另一个线程一个机会来运行，当选择下一个线程时，操作系统会考虑线程的优先级。

记住：在任何给定时刻，一个可运行的线程可能正在运行也可能没有运行。（正式因为这样，这个状态被称为“可运行”而不是“运行”）。

4.1.3. 阻塞和等待线程

当线程处于阻塞或者等待状态时，它暂时是不活动的。它不运行任何的代码，而且消耗最少的资源。

当一个线程视图获取一个内部对象锁的时候，而这个锁目前正在被其他线程占用，则该线程就会被阻塞。当有其他线程释放了这个锁，并且线程调度器允许该线程持有这个锁时，他将变成非阻塞状态。
当线程等待另一个线程通知调度器出现一个条件时，这个线程就进入等待状态。调用Object.wait方法或者Thread.join方法，或者是等待java.util.concurrent库中的Lock或者Condition时，就会出现这种情况。实际上，阻塞状态和等待状态并没有多大区别。
有几个方法有超时参数，调用这些方法就会让线程进入计时等待（Timed Waiting），这一状态将一直保持到超时期满或者接受到适当的通知。带有超时参数的方法有Thread.sleep和计时版的Object.wait、Thread.join、Lock.tryLock以及Condition.await。

4.1.4. 终止线程

线程会由于以下两个原因之一而终止：

run方法的正常退出，线程自然终止。
因为一个没有捕获的异常终止了run方法，使线程异常终止。

4.2. 线程状态转换

在这里插入图片描述

4.2.1. 众人上厕所问题与线程状态对应理解。

5. Java中多线程的线程同步----卖票案例

5.1. 案例需求

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

5.2. 实现步骤

定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

在SellTicket类中重写run()方法实现卖票，代码步骤如下

判断票数大于0，就卖票，并告知是哪个窗口卖的
卖了票之后，总票数要减1
票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行

package com.itlearn.sell;

public class SellTicket implements Runnable{
    private Integer tickets = 100;
    @Override
    public void run() {
        while (true){
            if (tickets > 0){         	System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

定义一个测试类SellTicketDemo，里面有main方法

创建SellTicket类的对象
创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
启动线程

package com.itlearn.sell;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();

        Thread thread1 = new Thread(sellTicket,"窗口1");
        Thread thread2 = new Thread(sellTicket,"窗口2");
        Thread thread3 = new Thread(sellTicket,"窗口3");

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

5.3. 执行结果

在这里插入图片描述

5.4. 执行结果分析

从上述执行结果看，似乎没有什么问题，但是在实际生活中，售票时是需要时间的，所以，在出售一张票的时候，需要一点时间的延迟。所以，我们可以借此来改进程序，设置每次出票时间为100毫秒，使用sleep方法来实现。

package com.itlearn.sell;

public class SellTicket implements Runnable{
    private Integer tickets = 100;
    @Override
    public void run() {
        while (true){
            if (tickets > 0){
                try {
                    //使线程休眠100毫秒，来模拟出票延迟
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                tickets--;
            }
        }
    }
}

运行结果：

在这里插入图片描述

6. 卖票案例中存在的问题分析

6.1. 出现的问题

相同的票出现了多次，且有票丢失
出现了负数的票

6.2. 出现该问题的原因

6.2.1. 相同的票出现了多次，且有票丢失

public class SellTicket implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        //相同的票出现了多次
        while (true) {
            //tickets = 100;
            //t1,t2,t3
            //假设t1线程抢到CPU的执行权
            if (tickets > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
               //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
                //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
                tickets--;
                //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
            }
        }

6.2.2. 出现了负数的票

 //出现了负数的票
        while (true) {
            tickets = 1;
            //t1,t2,t3
            //假设t1线程抢到CPU的执行权
            if (tickets > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
                //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
                //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
                //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
                //假设t3继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}

7. 同步代码块解决多线程中数据安全的问题

7.1. 什么时候会出现数据安全的问题？

是否是多线程环境
是否有共享数据----如：出售的票
是否有多条语句操作共享数据-----如售票中多个线程操作同一个ticket对象

7.2. 如何解决多线程的安全问题呢？----（同步代码块方案）

基本思想：让程序没有出现安全问题的环境，即：破坏7.1中的三个条件

注意：7.1中，前两个条件是我们无法破坏的，我们只有在第三个条件之上进行操作以解决多线程数据安全问题。
实现方法：
把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可------Java提供了同步代码块的方式来解决

同步代码块的格式

synchronized(任意对象) { 
	多条语句操作共享数据的代码 
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

public void run() {
        while (true){
             synchronized (new Object()){
            	if (tickets > 0){
                    try {
                        //使线程休眠100毫秒，来模拟出票延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }
        }

可见：在执行售票程序中，加入了 synchronized（new Object())，即给该段程序加入了锁。因为synchronized(任意对象)参数使任意对象，则我们先随意new一个Obejct类的对象。下面来观察运行结果。

在这里插入图片描述

可以看到，这里我们明明加入了锁，为什么还是会出现同一张票出售多次的问题呢？

问题分析：

这里是因为，我们在程序段中虽然加入了锁（new Object()）,但是三个线程都可以运行到这里，并且每个线程都可以创建自己的锁，即，这里是每个线程都有自己的锁，这就导致了多把锁的现象，而我们需要的是只有一把锁，如上厕所现象中的锁一般，每个线程进入到这段代码的时候，会请求锁，如果有了锁才可以运行。

所以，我们只需要一把锁，即把new Object()的操作放到while外面，而在synchronized(任意对象)中，只传入我们new的对象引用即可。如下：

package com.itlearn.sell;

public class SellTicket implements Runnable{
    private Integer tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
            if (tickets > 0){
                    try {
                        //使线程休眠100毫秒，来模拟出票延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                    tickets--;
                }
            }
        }
    }
}

执行结果：

在这里插入图片描述

问题解决！

8. 同步方法解决数据安全问题

8.1. 同步方法介绍

同步方法：即将synchronized关键字加到方法上。使其对方法体进行加锁。

那么，在方法上加锁，就可以解决数据安全问题吗？所加的锁对象是谁的呢？请看下面程序。

package com.itlearn.sell;

public class SellTicket implements Runnable{
    private Integer tickets = 100;
    private Object obj = new Object();
    private Integer x = 0;
    @Override
    public void run() {
        while (true){
            if (x % 2 ==0){
                synchronized (obj){
                    if (tickets > 0){
                        try {
                            //使线程休眠100毫秒，来模拟出票延迟
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else {
                setTickets();
            }
            x++;
        }
    }
    
    public synchronized void setTickets(){
        if (tickets > 0){
            try {
                //使线程休眠100毫秒，来模拟出票延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
            tickets--;
        }
    }
}

执行结果：

在这里插入图片描述

可见：出现了数据安全问题。那么为什么会这样呢？

问题分析：

在上述代码中，虽然在方法上加上了synchronized，即，对该方法上了锁，但是，我们知道，一个类中的方法，只要不是静态方法，那么这个方法的实际操作对象是this，即本类的对象。而在run中，我们是对obj加入的锁，即两个锁并不是同一个锁，所以会出现该线程问题。

问题解决：【重点】

我们可以在run中，锁对象设置为this，即本类对象，那么就和方法中锁的对象保持一致了。如下代码：

public void run() {
        while (true){
            if (x % 2 ==0){
                synchronized (this){
                    if (tickets > 0){
                        try {
                            //使线程休眠100毫秒，来模拟出票延迟
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else {
                setTickets();
            }
            x++;
        }
    }

运行结果：

在这里插入图片描述

可见，线程问题解决。

8.2. 静态同步方法

同步静态方法：就是把synchronized关键字加到静态方法上。注意，静态方法属于类本身

修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

同步静态方法的锁对象是什么呢?

即：类的字节码文件：类名.class

package com.itlearn.sell;

public class SellTicket implements Runnable{
    private static Integer tickets = 100;
    private Integer x = 0;
    @Override
    public void run() {
        while (true){
            if (x % 2 ==0){
                synchronized (SellTicket.class){
                    if (tickets > 0){
                        try {
                            //使线程休眠100毫秒，来模拟出票延迟
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                        tickets--;
                    }
                }
            }else {
                setTickets();
            }
            x++;
        }
    }
    public static synchronized void sellTickets(){
        if (tickets > 0){
            try {
                //使线程休眠100毫秒，来模拟出票延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
            tickets--;
        }
    }
}

注意：静态方法只能操作静态成员变量，所以需要把tickets设为static。

9. Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。

ReentrantLock构造方法

方法名说明
ReentrantLock() 创建一个ReentrantLock的实例
加锁解锁方法

方法名说明
void lock() 获得锁
void unlock() 释放锁

方法名	说明
ReentrantLock()	创建一个ReentrantLock的实例

方法名	说明
void lock()	获得锁
void unlock()	释放锁

代码演示

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

10. 生产者和消费者模式----多线程协作问题

10.1.生产者和消费者模式概述

概述

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
什么是生产者消费者问题？

所谓生产者消费者问题，实际上主要是包含了两类线程：
1. 一类是生产者线程用于生产数据
2. 一类是消费者线程用于消费数据
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

下面介绍必要的Object类的等待和唤醒的方法

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

10.2. 生产者和消费者案例

案例需求

生产者消费者案例中包含的类：

奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作

消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

①创建奶箱对象，这是共享数据区域

②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

⑤启动线程

代码实现

public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;

    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");

        //生产完毕之后，修改奶箱状态
        state = true;

        //唤醒其他等待的线程
        notifyAll();
    }

    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");

        //消费完毕之后，修改奶箱状态
        state = false;

        //唤醒其他等待的线程
        notifyAll();
    }
}

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for(int i=1; i<=30; i++) {
            b.put(i);
        }
    }
}

public class Customer implements Runnable {
    private Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();

        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);

        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        //启动线程
        t1.start();
        t2.start();
    }
}

(int i=1; i<=30; i++) {
b.put(i);
}
}
}

public class Customer implements Runnable {
private Box b;

   public Customer(Box b) {
       this.b = b;
   }

   @Override
   public void run() {
       while (true) {
           b.get();
       }
   }

}

public class BoxDemo {
public static void main(String[] args) {
//创建奶箱对象，这是共享数据区域
Box b = new Box();

       //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
       Producer p = new Producer(b);
       //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
       Customer c = new Customer(b);

       //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
       Thread t1 = new Thread(p);
       Thread t2 = new Thread(c);

       //启动线程
       t1.start();
       t2.start();
   }

}