DAY14_多线程&线程安全问题&多线程经典案例-生产消费者模式

最新推荐文章于 2024-07-05 14:56:47 发布
最新推荐文章于 2024-07-05 14:56:47 发布
阅读量41 收藏
点赞数
分类专栏： 2.JavaSE进阶 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/130318880
版权

目录

1 实现多线程

1.1 简单了解多线程

  • 是指从软件或者硬件上实现多个线程并发执行的技术。
  • 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。
    在这里插入图片描述

1.2 并发和并行

  • 并行：在同一时刻，有多个指令在多个CPU上同时执行。
    在这里插入图片描述
  • 并发：在同一时刻，有多个指令在单个CPU上交替执行。
    在这里插入图片描述

1.3 进程和线程

  • 进程：是正在运行的程序
    • 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
    • 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
    • 并发性：任何进程都可以同其他进程一起并发执行
  • 线程：是进程中的单个顺序控制流，是一条执行路径
    • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
    • 多线程：一个进程如果有多条执行路径，则称为多线程程序
      在这里插入图片描述

1.4 实现多线程方式一：继承Thread类

  • 方法介绍
方法名说明
void run()在线程开启后，此方法将被调用执行
void start()使此线程开始执行，Java虚拟机会调用run方法()
  • 实现步骤
    • 定义一个类MyThread继承Thread类
    • 在MyThread类中重写run()方法
    • 创建MyThread类的对象
    • 启动线程
public class MyThread extends Thread {
    @Override
    public void run() {
        //代码就是线程在开启之后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了" + i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();

        //t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.
        //t2.run();
        //开启一条线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}
  • 两个小问题
    • 为什么要重写run()方法？
      • 因为run()是用来封装被线程执行的代码
    • run()方法和start()方法的区别？
      • run()：封装线程执行的代码，直接调用，相当于普通方法的调用
      • start()：启动线程；然后由JVM调用此线程的run()方法

1.5 实现多线程方式二：实现Runnable接口

  • Thread构造方法
方法名说明
Thread(Runnable target)分配一个新的Thread对象
Thread(Runnable target, String name)分配一个新的Thread对象
  • 实现步骤
    • 定义一个类MyRunnable实现Runnable接口
    • 在MyRunnable类中重写run()方法
    • 创建MyRunnable类的对象
    • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    • 启动线程
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建了一个参数的对象
        MyRunnable mr = new MyRunnable();
        //创建了一个线程对象,并把参数传递给这个线程.
        //在线程启动之后,执行的就是参数里面的run方法
        Thread t1 = new Thread(mr);
        //开启线程
        t1.start();

        MyRunnable mr2 = new MyRunnable();
        Thread t2 = new Thread(mr2);
        t2.start();
    }
}

1.6 实现多线程方式三: 实现Callable和Future接口

  • 方法介绍
方法名说明
V call()计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable< V > callable)创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()如有必要，等待计算完成，然后获取其结果
  • 实现步骤
    • 定义一个类MyCallable实现Callable接口
    • 在MyCallable类中重写call()方法
    • 创建MyCallable类的对象
    • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
    • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
    • 启动线程
    • 再调用get方法，就可以获取线程结束之后的结果。
import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);//报错

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

//        String s = ft.get();//不可以在开启线程之前获取结果

        //开启线程
        t1.start();
        String s = ft.get();

        System.out.println(s);
    }
}

在这里插入图片描述

1.7 实现多线程三种方式的对比

  • 实现Runnable、Callable接口
    • 好处: 扩展性强，实现该接口的同时还可以继承其他的类
    • 缺点: 编程相对复杂，不能直接使用Thread类中的方法
  • 继承Thread类
    • 好处: 编程比较简单，可以直接使用Thread类中的方法
    • 缺点: 可以扩展性较差，不能再继承其他的类

1.8 线程类常见方法

1.8.1 获取和设置线程名称

方法名说明
String getName()返回此线程的名称
void setName(String name)将此线程的名称更改为等于参数name
通过构造方法也可以设置线程名称
public class MyThread extends Thread {

    public MyThread() {
    }

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@@@" + i);
        }
    }
}

public class Demo {
    //1,线程是有默认名字的,格式:Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread("小蔡");
        MyThread t2 = new MyThread("小强");

        //t1.setName("小蔡");
        //t2.setName("小强");

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

1.8.2 获得当前线程的对象

方法名说明
Thread currentThread()返回对当前正在执行的线程对象的引用
public class Demo {
    public static void main(String[] args) {
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

1.8.3 线程休眠

方法名说明
static void sleep(long millis)使当前正在执行的线程停留（暂停执行）指定的毫秒数
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

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

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

1.8.4 线程调度

  • 多线程的并发运行
    • 计算机中的CPU，在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。
    • 各个线程轮流获得CPU的使用权，分别执行各自的任务。
  • 线程有两种调度模型
    • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
    • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程
      获取的 CPU 时间片相对多一些
  • Java使用的是抢占式调度模型
  • 随机性
    • 假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

在这里插入图片描述

1.8.5 线程的优先级

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

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}

import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        //System.out.println(t1.getPriority());//默认值为5
        t1.setPriority(10);
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        //System.out.println(t2.getPriority());//默认值为5
        t2.setPriority(1);
        t2.start();
    }
}

1.8.6 后台线程/守护线程

方法名说明
void setDaemon(boolean on)将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"---"+i);
        }
    }
}

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

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.setName("女神");
        t2.setName("备胎");
        //把第二个线程设置为守护线程
        //当普通线程执行完毕之后，那么守护线程也没有继续执行下去的必要了
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

1.8.7 线程生命周期

在这里插入图片描述

2 线程安全问题

2.1 案例1 卖票

  • 案例需求
    • 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
  • 思路
    • 定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;
    • 在Ticket类中重写run()方法实现卖票，代码步骤如下
      • A：判断票数大于0，就卖票，并告知是哪个窗口卖的
      • B：票数要减1
      • C：卖光之后，线程停止
    • 定义一个测试类TicketDemo，里面有main方法，代码步骤如下
      • A：创建Ticket类的对象
      • B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称
      • C：启动线程
  • 实现步骤
    • 定义
    • 在SellTicket类中重写run()方法实现卖票，代码步骤如下
    • 判断票数大于0，就卖票，并告知是哪个窗口卖的
    • 卖了票之后，总票数要减1
    • 票卖没了，线程停止
    • 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
    • 创建SellTicket类的对象
    • 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
    • 启动线程
public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket == 0) {
                //卖完了
                break;
            } else {
                ticket--;
                System.out.println(Thread.currentThread().getName() + "在卖票，还剩下" + ticket + "张票");
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //这样就是每一个线程都有100张票，错误的
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/

        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

2.2 卖票案例的思考

刚才写的电影院卖票程序，好像没有什么问题。但是在实际生活中，售票时出票也是需要时间的，
所以，在出售一张票的时候，需要一点时间的延迟，接下来我们去修改卖票程序中卖票的动作：
每次出票时间100毫秒，用sleep()方法实现

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket <= 0) {
                //卖完了
                break;
            } else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket--;
                System.out.println(Thread.currentThread().getName() + "在卖票，还剩下" + ticket + "张票");
            }
        }
    }
}
  • 卖票出现了问题
    • 相同的票出现了多次
    • 出现了负数的票
  • 问题原因
    • 线程执行的随机性导致的，可能在卖票过程中丢失cpu的执行权,导致出现问题

2.3 卖票案例数据安全问题的解决

  • 为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)
    • 多线程操作共享数据
    • 是多线程环境
    • 有共享数据
  • 如何解决多线程安全问题呢?
    • 基本思想：让程序没有安全问题的环境
  • 怎么实现呢?
    • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
    • Java提供了同步代码块的方式来解决
public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj){
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票，还剩下" + ticket + "张票");
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //这样就是每一个线程都有100张票，错误的
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/

        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

2.4 同步代码块

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

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

  • 默认情况是打开的，只要有一个线程进去执行代码了，锁就会关闭
  • 当线程执行完出来了，锁才会自动打开
  • 同步的好处和弊端
    • 好处：解决了多线程的数据安全问题
    • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
public class MyThread extends Thread {
    private static int ticketCount = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) { //就是当前的线程对象.
                if (ticketCount <= 0) {
                    //卖完了
                    break;
                } else {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketCount--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("窗口一");
        t2.setName("窗口二");

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

2.5 同步方法

  • 同步方法
    • 就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) { 
 方法体；
}
  • 同步方法的锁对象是什么呢?
    • this
  • 静态同步方法
    • 就是把synchronized关键字加到静态方法上
 修饰符 static synchronized 返回值类型 方法名(方法参数) { 
 方法体；
}
  • 同步静态方法的锁对象是什么呢?
    • 类名.class
  • 同步代码块和同步方法的区别
    • 同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码
    • 同步代码块可以指定锁对象,同步方法不能指定锁对象
public class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        while (true) {
            if ("窗口一".equals(Thread.currentThread().getName())) {
                //同步方法
                boolean result = synchronizedMthod();
                if (result) {
                    break;
                }
            }

            if ("窗口二".equals(Thread.currentThread().getName())) {
                //同步代码块
                synchronized (MyRunnable.class) {
                    if (ticketCount == 0) {
                        break;
                    } else {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }
        }
    }

    private static synchronized boolean synchronizedMthod() {
        if (ticketCount == 0) {
            return true;
        } else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

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

        t1.setName("窗口一");
        t2.setName("窗口二");

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

2.6 Lock锁

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

  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
方法名说明
ReentrantLock()创建一个ReentrantLock的实例
  • Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
    • Lock中提供了获得锁和释放锁的方法
方法名说明
void lock()获得锁
void unlock()释放锁
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //synchronized (obj){//多个线程必须使用同一把锁.
            try {
                lock.lock();
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    Thread.sleep(100);
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            // }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();

        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/

        Ticket ticket = new Ticket();

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

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

2.7 死锁

  • 概述
    • 线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。
  • 什么情况下会产生死锁
    • 资源有限
    • 同步嵌套
public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(() -> {
            while (true) {
                synchronized (objA) {
                    //线程一
                    synchronized (objB) {
                        System.out.println("小康同学正在走路");//一直都是小康同学正在走路
                    }
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                synchronized (objB) {
                    //线程二
                    synchronized (objA) {
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

3 生产者消费者

3.1 生产者和消费者模式概述

  • 生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻
  • 所谓生产者消费者问题，实际上主要是包含了两类线程：
    • 一类是生产者线程用于生产数据
    • 一类是消费者线程用于消费数据
  • 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
    • 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
    • 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

3.2 等待和唤醒的方法

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

3.3 生产者和消费者案例

  • 案例需求
    • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
      • 判断是否有包子,决定当前线程是否执行
      • 如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
      • 生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
      • 判断是否有包子,决定当前线程是否执行
      • 如果没有包子,就进入等待状态,如果有包子,就消费包子
      • 消费包子后,更新桌子上包子状态,唤醒生产者生产包子
    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
      • 创建生产者线程和消费者线程对象
      • 分别开启两个线程
public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;

    //汉堡包的总数量
    public static int count = 10;

    //锁对象
    public static final Object lock = new Object();
}

public class Foodie extends Thread {
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.flag) {
                        //有
                        System.out.println("吃货在吃汉堡包");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    } else {
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Cooker extends Thread {
    //    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (!Desk.flag) {
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    } else {
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/

        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Foodie f = new Foodie();
        Cooker c = new Cooker();

        f.start();
        c.start();
    }
}

3.4 生产者和消费者案例优化

  • 需求
    • 将Desk类中的变量,采用面向对象的方式封装起来
    • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
    • 创建生产者和消费者线程对象,构造方法中传入Desk类对象
    • 开启两个线程
public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
    // private int count = 10;
    private int count;

    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
        this(false, 10);
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            synchronized (desk.getLock()) {
                if (desk.getCount() == 0) {
                    break;
                } else {
                    //System.out.println("验证一下是否执行了");
                    if (desk.isFlag()) {
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    } else {
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while (true) {
            synchronized (desk.getLock()) {
                if (desk.getCount() == 0) {
                    break;
                } else {
                    //System.out.println("验证一下是否执行了");
                    if (!desk.isFlag()) {
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    } else {
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/



        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Desk desk = new Desk();
        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);
        f.start();
        c.start();
    }
}

3.5 阻塞队列基本使用

  • 阻塞队列继承结构
    在这里插入图片描述
  • 阻塞队列实现等待唤醒机制
    • 常见BlockingQueue:
      • ArrayBlockingQueue: 底层是数组,有界
      • LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值
    • BlockingQueue的核心方法:
      • put(anObject): 将参数放入队列,如果放不进去会阻塞
      • take(): 取出第一个数据,取不到会阻塞
import java.util.concurrent.ArrayBlockingQueue;

public class test {
    public static void main(String[] args) throws Exception {
        // 创建阻塞队列的对象,容量为 1
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);

        // 存储元素
        arrayBlockingQueue.put("汉堡包");

        // 取元素
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞

        System.out.println("程序结束了");
    }
}

3.6 阻塞队列实现等待唤醒机制案例

  • 案例需求
    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
      • 构造方法中接收一个阻塞队列对象
      • 在run方法中循环向阻塞队列中添加包子
      • 打印添加结果
    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
      • 构造方法中接收一个阻塞队列对象
      • 在run方法中循环获取阻塞队列中的包子
      • 打印获取结果
    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
      • 创建阻塞队列对象
      • 创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象
      • 分别开启两个线程
import java.util.concurrent.ArrayBlockingQueue;

public class Cooker extends Thread {

    private ArrayBlockingQueue<String> bd;

    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;

    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;

public class Demo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);

        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);

        f.start();
        c.start();
    }
}
_-Mr-sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程并发上传实例_多线程 网络编程 文件上传案例多线程
weixin_33509203的博客
02-26 1216
Day13 多线程3).多线程的好处：提高程序的运行效率，提高用户的体验度。 线程不会因为等待某个资源而进入等待状态创建新的线程:* 定义类继承Thread* 重写方法run* 创建Thread子类的对象* 调用子类对象的方法start()** 为什么继承Thread* Thread类是线程对象类* 继承了Thread,子类也是线程对象** 为什么重写run...
day14_多线程01.zip
09-12
总之，“day14_多线程01”这个资源可能涵盖了多线程的基本概念、创建与管理线程的方法、线程同步和安全、以及多线程在实际开发中的应用。学习多线程是提升编程技能的重要步骤，它能帮助开发者设计出更加高效、响应...
【并发编程】（三）多线程带来的线程安全问题
积木成林，聚沙成塔
12-25 831
线程安全问题指的是多个线程访问共享资源时，在缺少同步措施的情况下对共享资源进行了写操作而导致的执行结果与预期值不符的情况。但如果多个线程只是共同读取共享资源，不进行写操作是不会有线程安全问题的。共享资源：就是多个线程都可以共同访问的资源，例如：在JVM中，处于堆、方法区中的对象。① 造成线程安全问题的原因是程序代码不具备三个特性——原子性、可见性、有序性。② 使用volatile修饰变量，能解决变量的可见性和有序性问题，Java中的原子性操作往往加上volatile修饰被操作的字段就能保证线程安全。
【JAVA多线程】如何解决一个生产者与消费者问题
热门推荐
阳阳的博客
11-01 1万+
如何解决一个生产者与消费者问题 生产者与消费者问题是多线程同步的一个经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。我们需要保证的是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。 下面介绍java中几种解决同步问题的方式 （1）wait()与notify()方法...
Lesson_for_java_day20--java的多线程——生产者消费者模式(优化网上生产馒头的案例)
u013233075的专栏
05-03 1159
一、生产者消费者模式：
day13-多线程&网络编程
qq_74289024的博客
05-13 956
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程。/* 新建 */NEW ,/* 可运行状态 */RUNNABLE ,/* 阻塞状态 */BLOCKED ,/* 无限等待状态 */WAITING ,/* 计时等待 *//* 终止 */TERMINATED;// 获取当前线程的状态通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下。
day02_eesy_01anno_ioc_多线程_
10-02
本课程“day02_eesy_01anno_ioc_多线程”主要聚焦于Spring框架的核心特性——IOC（Inversion of Control，控制反转）以及其在多线程环境下的应用。 首先，让我们深入理解什么是IOC。控制反转是一种设计模式，它将...
多线程-day02.docx
12-12
在“多线程-day02”的学习资源中，我们深入探讨了Java内存模型以及多线程的特性与控制机制。 **Java内存模型** Java内存模型，也称为JVM内存模型，是Java程序员理解和掌握的基础知识，特别是在进行并发编程时。它...
多线程-day01.docx
12-12
线程安全问题是指在多线程环境下，对共享资源的访问可能导致数据不一致或者错误结果的问题。解决线程安全问题的方法包括同步机制（如 synchronized 关键字）、锁（如 ReentrantLock）、原子变量（如 AtomicInteger）...
day17_线程创建、线程同步、线程状态.pdf
11-02
Java多线程编程基础知识点 本节课主要讲解了Java多线程编程的基础知识，包括线程的概念、线程与进程的区别、多线程的随机性、Java程序的进程中的线程、线程的创建方式、线程的执行流程、线程内存图等。 1. 进程与...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 523
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
Casual_Lei的博客
07-04 646
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 335
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 221
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 911
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 602
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 259
定义返回值类型处理器的组合；测试使用的controller测试方法。
Java中的静态代理与动态代理详解
07-03 397
在Java中，代理模式分为静态代理和动态代理两种形式。缺点是每一个代理类只能为一个接口服务，如果接口增加方法，代理类也需要相应修改。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！静态代理是在编译时就已经确定代理类的实现，代理类与真实类实现相同的接口或继承相同的父类。动态代理是在运行时动态生成代理类，无需手动编写代理类，可以根据需要代理任意接口。通过本文的介绍，相信大家对Java中的静态代理和动态代理有了更深入的理解和应用。
基于springboot的工作绩效管理系统的设计与实现+文档
最新发布
欧阳小白闯天涯
07-05 657
本毕业设计旨在设计与实现基于Spring Boot的工作绩效管理系统，以满足现代企业对绩效管理的需求。随着企业规模的不断扩大和竞争日益激烈，高效的绩效管理成为提升企业竞争力的重要手段。本系统将利用Spring Boot框架搭建，结合MySQL数据库和MyBatis持久层框架，以及Thymeleaf模板引擎，为企业提供全面的绩效管理解决方案。系统功能包括员工和管理员两个角色。员工可通过系统进行绩效管理、工资管理、统计分析、请假管理以及公告管理等操作，从而提升工作效率和满足个人需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值