从0学开发笔记-线程

原创 于 2021-04-25 18:48:15 发布 · 62 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线程

本文深入探讨Java多线程的基础概念和技术实现，包括进程与线程的区别、主线程的特性、多线程创建方法及线程安全问题的解决策略等核心内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.并发、并行

在这里插入图片描述

2.进程与线程

在这里插入图片描述

在这里插入图片描述
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行的基本单位；系统运行一个程序即是一个进程从创建、运行、到消亡的过程。
线程：线程是进程中的一个单元，负责当前进程中程序执行，一个进程中至少有一个线程。一个进程中是可以又多个线程的，这个应用程序也可以称之为多线程程序。
总而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

3. 主线程

在这里插入图片描述

package demo01;
/*
    主线程：执行主（main）方法的线程

    单线程程序：java程序中只有一个线程
    执行从main方法开始，从上到下一次执行

    JVM执行main方法，main方法会进入到栈内存
    JVM会找操作系统开辟一条main方法通向cpu的执行路径
    cpu就可以通过这个路径来执行main方法
    而这个路径有一个名字，叫main（）线程

    主线程的弊端：一旦出现异常，同一个线程的程序都不能执行了
 */
public class MainThread {
    public static void main(String[] args) {
        Person person01 = new Person("小强");
        Person person02 = new Person("小明");
        person01.run();
        person02.run();
    }

}


package demo01;

public class Person {
    private String name;

    public void run(){
        //定义循环，执行20次
        for (int i=1; i<=20; i++){
            System.out.println(name+"--->"+i);
        }
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

4. 创建多线程程序的第一种方式

package demo01;
/*
    创建多线程程序的第一种方式：创建Thread类的子类
    java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

    实现步骤：
        1.创建一个Thread类的子类
        2.在Thread类的子类种重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
        3.创建Thread类的子类对象
        4.调用Thread类种的方法start方法，开启新的线程，执行run方法
            void start() 使该线程开始执行；java虚拟机调用该线程的run方法
            结果是两个线程并发地运行；当前线程（main）和另一个线程（创建的新线程，执行其run方法）
            多次启动一个线程是非法的，特别是当前线程已经执行结束后，不能再重新启动
        java程序属于抢占式调度，哪个线程的优先级最高，哪个线程优先执行；同一个优先级，随机选择一个执行
 */
public class Demo01Thread {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        for (int i=1; i<20; i++){
            System.out.println("main:"+i);
        }
        //main:1
        //run:1
        //main:2
        //run:2
        //main:3
        //run:3
        //main:4
        //run:4
        //main:5
        //run:5
        //main:6
        //run:6
        //main:7
        //run:7
        //main:8
        //run:8
        //main:9
        //run:9
        //main:10
        //run:10
        //main:11
        //run:11
        //main:12
        //run:12
        //run:13
        //run:14
        //main:13
        //run:15
        //main:14
        //run:16
        //main:15
        //run:17
        //main:16
        //run:18
        //main:17
        //run:19
        //main:18
        //run:20
        //main:19



    }

}


package demo01;

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i=1; i<=20; i++){
            System.out.println("run:"+i);
        }
    }
}

5. 多线程原理

在这里插入图片描述
cpu不是多核并行的么？
网上的说法是：小任务量时就不必并行处理了

6. 多线程的内存图解

在这里插入图片描述

7. Thread类的常用方法

7.1 获取线程名称

package demo01;
/*
    线程的名称：
        主线程：main
        新线程：Thread-0，Thread-1，Thread-2
 */
public class Demo01GetThreadName {
    public static void main(String[] args) {
        //创建thread类的子类对象
        Demo02MyThread mt1 = new Demo02MyThread();
        //调用start方法，开启新线程，执行run方法
        mt1.start();

        new Demo02MyThread().start();
        new Demo02MyThread().start();
        //Thread[Thread-1,5,main]
        //Thread[Thread-2,5,main]
        //Thread-2
        //Thread[Thread-0,5,main]
        //Thread-0
        //Thread-1    //因为3个线程时随机执行的，所以不是连续的

        //链式编程
        System.out.println(Thread.currentThread().getName());



    }
}


package demo01;

import java.util.TreeMap;

/*
    获取线程的名称：
        1.使用Thread类中的方法getName()
            String getName() 返回该线程的名称
        2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
            static Thread currentThread() 返回对当前正在执行的线程对象引用。
 */
public class Demo02MyThread extends Thread{
    //重写Thread类中的run方法，设置线程任务
    @Override
    public void run() {
        //获取线程名称
//        String name = getName();
//        System.out.println(name);

        Thread t = Thread.currentThread();
        System.out.println(t);

        String name = getName();
        System.out.println(name);
    }
}

7.2 设置线程名称

package demo01;

public class Demo01SetName {
    public static void main(String[] args) {
        SetNameMyThread mt1 = new SetNameMyThread();
        mt1.setName("小强");
        mt1.start();

        new SetNameMyThread("旺财").start();

    }
}


package demo01;
/*
    设置线程的名称：（了解）
        1.使用Thread类中的方法setName（名字）
            void setName(String name)改变线程名称，使之与参数name相同。
        2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，
          把线程名称传递给父类，让父类（Thread）给子线程起一个名字
            Tread(String name)分配新的Thread对象
 */
public class SetNameMyThread extends Thread {


    public SetNameMyThread(){

    }

    public SetNameMyThread(String name){
        super(name);
    }


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

7.3 sleep方法

package demo01;
/*
    public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
    毫秒数结束之后，线程继续执行
 */
public class Demo01Sleep {
    public static void main(String[] args) {
        for (int i=1; i<=60; i++){
            System.out.println(i);

            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

8 创建线程的第二种方式

package demo01;
/*
    创建多线程程序的第二种方式：实现Runnable接口
    java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现，
        类必须定义一个称为 run的无参方法
    java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的Thread对象
        Thread(Runnable target,String name)分配新的 Thread对象

    实现步骤：
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法，设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
        5.调用Thread类中的start方法，开启新的线程执行run方法
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        RunnableImp run = new RunnableImp();
        Thread t = new Thread(run);
        t.start();

        for (int i=1; i<20 ;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}

9.Runnable创建线程的好处

package demo01;
/*
    创建多线程程序的第二种方式：实现Runnable接口
    java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现，
        类必须定义一个称为 run的无参方法
    java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的Thread对象
        Thread(Runnable target,String name)分配新的 Thread对象

    实现步骤：
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法，设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象，构造方法中传递Runnable接口中的实现类对象
        5.调用Thread类中的start方法，开启新的线程执行run方法

    实现Runnable接口创建多线程程序的好处：
        1.避免了单继承的局限性
            一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其他的类
            实现了Runnable接口，还可以继承其他的类，实现其他的接口
        2.增强了程序的扩展性，降低了程序的耦合性（解耦）（传递不同的实现类实现不同的任务）
            实现Runnable接口方式，把设置线程任务和开启新线程进行了分离（解耦）
            实现类中，重写了run方法：用来设置线程任务
            创建Thread类对象，调用start方法：用来开启新的线程
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        RunnableImp run = new RunnableImp();
        Thread t = new Thread(run);
        t.start();

        for (int i=1; i<20 ;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

}

10.匿名内部类方式实现线程的创建

package demo02;

public class ClassThread {
    /*
        匿名内部类方式实现线程的创建

        匿名：没有名字
        内部类：写在其他类内部的类

        匿名内部类作用：简化代码
            把子类继承父类，重写父类的方法，创建子类对象合成一步完成
            把实现类实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
        匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

        格式：
            new 父类/接口(){
                重复父类/接口中的方法

            }

      匿名对象，就是直接new 类名 没有对象名称，直接new一个对象
      匿名内部类：就是在一个类中 new一个对象（父类的子类对象或者接口的实现类对象），没有对象名字；
      并且重写父类或者接口的方法。
     */
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            //重写run方法，设置线程任务。
            @Override
            public void run() {
                for (int i=1;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"--->"+"黑马");
                }
            }
        }.start();
        //线程接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            @Override
            public void run() {
                for (int i=1;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"--->"+"程序员");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i=1;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"--->"+"传智播客");
                }
            }
        }).start();
    }
}

11. 线程安全问题

在这里插入图片描述

package demo02;

public class DemoTicket {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImp run = new RunnableImp();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);

        t0.start();
        t1.start();
        t2.start();//会出现多个线程卖同一张票，


    }
}


package demo02;

public class RunnableImp implements Runnable {
    //定义一个多线程共享票源
    private int ticket = 100;

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环
        while(true){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }


    }
}

12.线程安全问题产生的原因

在这里插入图片描述
出现重复票和不存在的票的主要原因是因为三个线程同时执行run，然后进去以后执行if以后就会休眠，这样三个线程在if后面都休眠了（并非同时），然后第一个醒过来的线程执行（ticket=0）ticket–，ticket就为0了，然后第二个线程醒过来以后又执行ticket–，第三个线程醒过来又执行ticket–

13.解决线程安全问题-同步代码块

package demo02;

public class DemoTicket1 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImp1 run = new RunnableImp1();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);

        t0.start();
        t1.start();
        t2.start();


    }
}


package demo02;
/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全的问题的一种方案：使用同步代码块
    格式：
        synchronized(锁对象){
            可能会出现线程安全问题的代码（访问了共享数据的代码）
        }
    注意：
        1.通过代码块中的锁对象，可以使用任意的对象
        2.但是必须保证多个线程使用的锁对象是同一个
        3.锁对象作用：
            把同步代码块锁住，只让一个线程在代码块中执行
 */
public class RunnableImp1 implements Runnable {
    //定义一个多线程共享票源
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环
        while(true){
            synchronized (obj){
                if (ticket>0){
                    //提高安全问题出现的概率，让程序睡眠
//                    try{
//                        Thread.sleep(10);
//                    }catch (InterruptedException e){
//                        e.printStackTrace();
//                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }
           }
        }
    }
}
//没有某一个线程的原因是因为某个线程可能就没抢到CPU的执行权，票就卖完了。

14.同步技术原理

在这里插入图片描述

15. 解决线程安全问题-同步方法

package demo03;

import demo02.RunnableImp1;

public class DemoTicket1 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImp1 run = new RunnableImp1();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);

        t0.start();
        t1.start();
        t2.start();


    }
}


package demo03;
/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全的问题的第二种方案：使用同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放到一个方法中
        2.在方法上添加synchronized
    格式：定义格式的方法
    修饰符 synchronized 返回值类型 方法名（参数列表）{
        可能会出现线程安全问题的代码（访问了共享数据代码）
    }
 */
public class RunnableImp1 implements Runnable {
    //定义一个多线程共享票源
    private int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环
        while(true){
            payTicket();

        }
    }
    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁？
        就是实现类对象 new RunnableImpl()
        也就是this
     */
    public synchronized void payTicket(){
        //判断票是否存在
        if (ticket>0){
            //提高安全问题出现的概率，让程序睡眠
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
            ticket--;
        }
    }


}

16.静态同步方法

package demo03;

import demo02.RunnableImp1;

public class DemoTicket1 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImp1 run = new RunnableImp1();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);

        t0.start();
        t1.start();
        t2.start();




    }
}


package demo03;

import demo02.RunnableImp;

/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全的问题的第二种方案：使用同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放到一个方法中
        2.在方法上添加synchronized
    格式：定义格式的方法
    修饰符 synchronized 返回值类型 方法名（参数列表）{
        可能会出现线程安全问题的代码（访问了共享数据代码）
    }
 */
public class RunnableImp1 implements Runnable {
    //定义一个多线程共享票源
    private static int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环
        while(true){
            payTicketStatic();

        }
    }
    /*
    静态的同步方法
    锁对象是谁？
    不能是this
    this是创建对象之后产生的，静态方法优先于对象
    静态方法的锁对象是本类的class属性--》文件的对象

     */
    public  static /*synchronized*/ void payTicketStatic(){
        //判断票是否存在
        synchronized (RunnableImp1.class){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }


}

17. Lock锁

package demo03.lock;

import demo02.RunnableImp1;

public class DemoTicket1 {
    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        RunnableImp1 run = new RunnableImp1();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);

        t0.start();
        t1.start();
        t2.start();




    }
}


package demo03.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全的问题的第三种方案：使用Lock锁
    java.util.concurrent,Locks.Lock接口
    Lock 实现提供了比使用synchronized方法和语句可获得更广泛的锁定操作
    Lock接口中的方法
        void Lock() 获取锁
        void unLock() 释放锁
    java.util.concurrent.Locks.ReentranLock implements Lock接口


    使用步骤:
        1.在成员位置创建又给ReentranLock对象
        2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
        3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁

 */
public class RunnableImp1 implements Runnable {
    //定义一个多线程共享票源
    private static int ticket = 100;


    //在成员位置创建又给ReentranLock对象
    Lock l = new ReentrantLock();


    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环
        while(true){
            l.lock();
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }catch (InterruptedException e){
                    e.printStackTrace();
                }finally {
                    l.unlock();//无论程序是否异常，都会把锁释放
                }

            }


        }
    }
    /*
    静态的同步方法
    锁对象是谁？
    不能是this
    this是创建对象之后产生的，静态方法优先于对象
    静态方法的锁对象是本类的class属性--》文件的对象

     */
    public  static /*synchronized*/ void payTicketStatic(){
        //判断票是否存在
        synchronized (RunnableImp1.class){
            if (ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }


}

18.线程的状态

在这里插入图片描述

19.等待唤醒案例分析

在这里插入图片描述

package demo03.demo03.waitandnotify;
/*
    等待唤醒案例：线程之间的通信
        创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，
        调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
        创建一个老板线程（生产者）：花了5秒钟做包子，做好包子之后，调用notify方法，唤醒顾客吃包子

    注意：
        顾客和老板线程必须使用同步代码包裹起来，保证等待和唤醒只能有一个在执行
        同步使用的锁对象必须保证唯一
        只有锁对象才能调用wait和notify方法

    Object类中的方法
    void wait()
        在其他线程调用此对象的notify()方法或者notifyAll方法前，导致当前线程等待
    void notify()
        唤醒在此对象监视器上等待的单个线程
        会继续执行wait方法之后的代码
 */
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run() {
                //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("告知老板要的包子的种类和数量");
                    //调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后的代码
                    System.out.println("包子好了，开吃");
                }
            }
        }.start();  //自己的线程主动等待wait,等待以后即使静态代码块没有执行完也其他线程也可以执行

        new Thread(){
            @Override
            public void run() {
                //花5秒做包子
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj){
                    System.out.println("老板5秒钟之后做好包子，告知顾客，可以吃包子了");
                    //做好包子之后，调用notify方法，唤醒顾客吃包子了
                    obj.notify();`在这里插入代码片`

                }
            }
        }.start();    //唤醒其他线程notify

    }
}

Object类中的wait带参方法和notify

package demo03.demo03.waitandnotify;
/*
    进入到TimeWaiting（计时等待）有两种方式
    1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Block状态
    2.使用wait(long m)方法，在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，
    线程睡醒进入到Runnable/Block状态

    唤醒方法：
        void notify() 唤醒在此监视器上等待的单线程
        void notifyAll() 唤醒在此对象监视器上等待的所有线程

 */
public class Demo02WaitAndNotify {
    public static void main(String[] args) {

        //创建一个锁对象
        Object obj = new Object();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客1告知老板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
                        try {
                            //obj.wait(5000);  //和sleep一样只不过可以在没到时间的情况下被唤醒
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后的代码
                        System.out.println("包子好了，顾客1开吃");
                    }
                }

            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客2告知老板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后的代码
                        System.out.println("包子好了，顾客2开吃");
                    }
                }

            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子，告知顾客，可以吃包子了");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
                        obj.notify();//如果有多个等待线程，唤醒随机一个
                        //obj.notifyAll();//唤醒多有等待的线程

                    }
                }

            }
        }.start();

    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值