多线程、线程同步、生产者消费者问题

最新推荐文章于 2024-07-22 14:15:06 发布

LCQ5279

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量30

点赞数

分类专栏：多线程&JUC并发编程文章标签： java

本文链接：https://blog.csdn.net/LCQ5279/article/details/134934456

版权

多线程&JUC并发编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.实现多线程

1.1简单了解多线程【理解】

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

01_简单了解多线程

1.2并发和并行【理解】

并行：在同一时刻，有多个指令在多个CPU上同时执行。
并发：在同一时刻，有多个指令在单个CPU上交替执行。

1.3进程和线程【理解】

进程：是正在运行的程序

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
并发性：任何进程都可以同其他进程一起并发执行
线程：是进程中的单个顺序控制流，是一条执行路径

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

多线程：一个进程如果有多条执行路径，则称为多线程程序

1.4实现多线程方式一：继承Thread类【应用】

方法介绍

方法名说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法()
实现步骤
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程

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

代码演示

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

//        my1.run();
//        my2.run();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.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对象作为构造方法的参数
- 启动线程

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

代码演示

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 MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");

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

1.6实现多线程方式三: 实现Callable接口【应用】

方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

实现步骤
- 定义一个类MyCallable实现Callable接口
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果。

代码演示

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

        //开启线程
        t1.start();

        String s = ft.get();
        System.out.println(s);
    }
}

注意ft.get() 方法是一个阻塞方法，它会等待直到 Callable 完成执行并返回结果。

所以获取结果的代码要在开启线程之后进行，要不然主线程就会陷入无尽的等待之中。

三种实现方式的对比

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

1.7设置和获取线程名称【应用】

方法介绍

方法名说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

代码演示

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 MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

1.8线程休眠【应用】

相关方法

方法名说明
static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数

方法名	说明
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("睡觉前");
        // 使得主线程睡了3000毫秒
        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.9线程优先级【应用】

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

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

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

代码演示

MyCallable

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);
        }
        System.out.println(Thread.currentThread().getName() + "执行完毕了");
        return Thread.currentThread().getName() + "执行完毕了";
    }
}

不设置优先级

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<String> ft1 = new FutureTask<>(mc);
      FutureTask<String> ft2 = new FutureTask<>(mc);
        Thread t1 = new Thread(ft1);
      Thread t2 = new Thread(ft2);
        t1.setName("飞机");
      t2.setName("坦克");
        t1.start();
        t2.start();
    }
}

运行结果：

设置优先级

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<String> ft1 = new FutureTask<>(mc);
        FutureTask<String> ft2 = new FutureTask<>(mc);
        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2);
        t1.setName("飞机");
        t2.setName("坦克");
        t1.setPriority(10);
        t2.setPriority(1);
        t1.start();
        t2.start();
    }
}

执行结果没变

设置线程优先级在 Java 中并不保证线程的执行顺序。线程调度器负责决定哪个线程将运行，而且这个决定受多个因素影响，包括操作系统的线程调度策略和当前系统负载。Java 线程的优先级只是给线程调度器一个提示，但调度器不一定会严格遵循这个提示。

线程优先级的效果在不同的操作系统上表现可能不同。在有些操作系统上，优先级差异可能明显地影响线程的执行顺序；而在其他系统上，这种影响可能微不足道或完全没有。此外，即使在优先级对线程调度有较大影响的系统上，线程优先级也不能作为程序正确性的依据。通常不应该依赖线程优先级来确保线程的执行序列或者正确性。

在你的程序中，即使设置了不同的优先级，两个线程仍然可能交替执行，因为线程调度器可能会频繁地在它们之间切换。此外，如果线程的任务很小，它们可能在操作系统调度器采取任何行动之前就已经完成了，这使得优先级的影响变得不那么明显。

如果你需要更精确地控制线程的执行顺序，你可能需要使用其他的并发控制机制，如 synchronized 关键字、锁（Lock 接口）、信号量（Semaphore）、倒计时锑（CountDownLatch）等来协调线程之间的交互。

1.10守护线程【应用】

守护线程（Daemon Thread）在 Java 中是一种特殊的线程，主要用作程序中的辅助线程，它的用法如下：

特性

生命周期：守护线程的生命周期依赖于创建它的程序的剩余非守护线程。当所有非守护线程结束时，JVM会自动终止所有守护线程。
用途：守护线程通常用于执行后台任务，如垃圾收集器（GC）。
注意事项：由于守护线程可能随时终止，因此不应该用于执行关键性任务，如文件写操作和数据库事务处理。

用法

设置守护线程的方法很简单，只需要在启动线程之前调用 Thread.setDaemon(true) 方法。下面是一个简单的示例：

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                doSomeWork(); // 执行后台任务
            }
        });

        // 将线程设置为守护线程
        daemonThread.setDaemon(true);

        // 启动守护线程
        daemonThread.start();

        // 主线程的其他代码
        doMainWork();
    }

    private static void doSomeWork() {
        // 守护线程执行的代码
    }

    private static void doMainWork() {
        // 主线程执行的代码
    }
}

在这个例子中，daemonThread 被设置为守护线程。这意味着它将在 main 方法中的其他非守护线程（即主线程）结束时自动终止。需要注意的是，daemonThread 里面是一个无限循环，在 main 线程完成工作后，daemonThread 将不会再执行，JVM将退出。

注意点

必须在启动线程之前调用 setDaemon(true)。一旦线程开始运行（即调用了 start() 方法），你就不能再修改它的守护状态了。
守护线程不应该用于执行重要的、需要确保完成的任务，因为它们在JVM退出时可能不会正常完成。
守护线程创建的任何子线程默认也是守护线程。
相关方法

方法名说明
void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

方法名	说明
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();
    }
}

2.线程同步

2.1卖票【应用】

案例需求

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

代码实现

public class MyThread extends Thread{
    int ticket = 0;// 0~99

    @Override
    public void run() {
        while (true) {
            if (ticket < 100) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                ticket++;
                System.out.println(getName() + "正在卖第" + ticket + "票");
            } else {
                break;
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {

        // 创建线程对象
      MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 起名字
      t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

结果：

各个线程卖票互相独立，每个线程都卖了100张票

解决方法：将ticket变量前面加个static，让所有线程共享这个变量的值

结果

还是有的票被卖了多次，而且还出现了买了超过票号100的票

2.2同步代码块解决数据安全问题【应用】

安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
如何解决多线程安全问题呢?
- 基本思想：让程序没有安全问题的环境
怎么实现呢?
- 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式来解决
同步代码块格式：
```
synchronized(任意对象) { 
	多条语句操作共享数据的代码 
}
```
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
同步代码块把操作共享数据的代码锁起来。
特点

锁默认打开，有一个线程进去了，锁自动关闭。

里面的代码全部执行完毕，线程出来，锁自动打开。
细节

锁对象必须是唯一的，任意的

一般会将obj替换成当前类的字节码文件即MyThread.class，MyThread.class在同一个文件夹里面是唯一的，只有一个

synchronized要写在循环里面。（否则只会有一个线程可以卖票）

代码演示

public class MyThread extends Thread{
    // 表示这个类的所有对象，都共享这个ticket
    static int ticket = 0;// 0~99
  // 锁对象，一定要是唯一的
    static Object object = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (object) {// 一定要写在循环的里面
                if (ticket < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "票");
                } else {
                    break;
                }
            }
        }
    }
}

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

      // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

结果：确实只买了100张票，而且没有卖重复的票

2.3同步方法解决数据安全问题【应用】

同步方法：就是把synchronized关键字加到方法上。

特点：

同步方法是锁住方法里面的所有的代码

锁对象不能自己指定

非静态方法：this

静态：当前类的字节码文件对象

同步方法的格式

同步方法：就是把synchronized关键字加到方法上
```
修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}
```
同步方法的锁对象是什么呢?

this
静态同步方法

同步静态方法：就是把synchronized关键字加到静态方法上
```
修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}
```
同步静态方法的锁对象是什么呢?

类名.class

先用多线程的第二种方式写一下同步代码块：

public class MyRunnable implements Runnable{
    //细节：刚刚为什么要加static：因为多线程的第一种方式，MyThread这个类，
    // 它是有可能创建多个对象的，所以我想要所有的对象都共享ticket这个成员变量的值，
    // 那么在这个成员变量前面就得加static。
    //为什么多线程的第二种方式成员变量ticket前面不需要加static？
    //因为MyRunnable这个类只会创建一次对象，它是作为一个参数，让线程去执行的，
    // 所以只会创建一次它的对象。那成员变量ticket前面就没有必要加static
    int ticket = 0;

    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块（同步方法）
            synchronized (MyRunnable.class){
                //3.判断共享数据是否到了末尾，如果到了末尾
                if(ticket == 100){
                    break;
                }else{
                    //4.判断共享数据是否到了末尾，如果没有到末尾
                    try {
                        //睡一下，用来使得每个窗口都能卖票
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(Thread.currentThread().getName() + "在卖第" + ticket + "张票！！！");
                }
            }
        }
    }
}

再将同步代码块改为同步方法：就把synchronized的同步代码块中的所有代码全部放到方法之中就可以了。

选中synchronized中的所有代码，CTRL+alt+m，就可以抽取成一个方法，方法名字改一改叫做method，然后将synchronized删掉。在刚生成的方法上面添加synchronized就可以了。

public class MyRunnable implements Runnable{
    int ticket = 0;

    @Override
    public void run() {
        //1.循环
        while(true){
            //2.同步代码块（同步方法）
                if (method()) break;
        }
    }

//这个非静态方法的锁对象是this，而这个this其实就是我们测试类中创建的mr，在整个代码中，mr是唯一的，所以锁对象就是唯一的
    private synchronized boolean method() {
        //3.判断共享数据是否到了末尾，如果到了末尾
        if(ticket == 100){
            return true;
        }else{
            //4.判断共享数据是否到了末尾，如果没有到末尾
            try {
                //睡一下，用来使得每个窗口都能卖票
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在卖第" + ticket + "张票！！！");
        }
        return false;
    }
}

2.4Lock锁【应用】

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。

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

ReentrantLock构造方法

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

方法名说明
void lock() 获得锁
void unlock() 释放锁
代码演示

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

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

public class MyThread extends Thread{
    // 表示这个类的所有对象，都共享这个ticket
    static int ticket = 0;// 0~99
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            if (ticket < 100) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                ticket++;
                System.out.println(getName() + "正在卖第" + ticket + "票");
            } else {
                break;
            }
            lock.unlock();
        }
    }
}

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

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

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

此时还没完，由于没给锁加static，所以在new MyThread的时候会有多把锁，所以还会导致，买了重复的票，还会多买

解决方法：给锁也加上static

加上static以后确实实现了只卖100张票，没有重复的票

但是新的问题出现了：程序不停了，运行完卖票以后，程序不停止。

原因是：假设一直是线程1抢到锁，而线程2和线程3一直卡在lock.lock()那行代码等待着锁，而当线程1买完100张票时，它又抢到了锁，然后判断ticket < 100，结果不成立，所以他就直接break了，直接跳出while循环，但是它直接跳出去，没有执行lock.unlock()，所以线程2和3一直在那行等待着锁。

解决方法：

将解锁的代码放到try catch的finally里面。

将上锁后的代码全部用try catch包裹选中要try的代码，ctrl+alt+t，然后选择try catch finally

public class MyThread extends Thread{
    // 表示这个类的所有对象，都共享这个ticket
    static int ticket = 0;// 0~99
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket < 100) {
                    Thread.sleep(10);
                    ticket++;
                    System.out.println(getName() + "正在卖第" + ticket + "票");
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

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

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

        // 起名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

2.5死锁【理解】

概述

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
什么情况下会产生死锁
1. 资源有限
2. 同步嵌套

代码演示

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生产者和消费者模式概述【应用】

概述

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

所谓生产者消费者问题，实际上主要是包含了两类线程：

一类是生产者线程用于生产数据

一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

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

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

Object类的等待和唤醒方法

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

注意： notify和notifyAll不会释放锁，只是唤醒等待，而且唤醒的进程不会立即执行，只有等它抢到锁才执行。

3.2生产者和消费者案例【应用】

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

等待：

生产者：桌子上有面条

消费者：桌子上没有面条

唤醒：

当生产者生成了一份面条时，就会去唤醒消费者来消费面条

当消费者消费了一份面条时，就会去唤醒生产者来生成面条
循环结束：

10碗面条

代码实现

public class Desk {

    /*
    * 作用：控制生产者和消费者的执行
    *
    * */

    //是否有面条  0：没有面条  1：有面条
    public static int foodFlag = 0;

    //总个数
    public static int count = 10;

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

}


public class Cook extends Thread{

    @Override
    public void run() {
        /*
         * 1. 循环
         * 2. 同步代码块
         * 3. 判断共享数据是否到了末尾（到了末尾）
         * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
         * */

        while (true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    //判断桌子上是否有食物
                    if(Desk.foodFlag == 1){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                      //如果没有，就制作食物
                        System.out.println("厨师做了一碗面条");
                        //修改桌子上的食物状态
                        Desk.foodFlag = 1;
                        //叫醒等待的消费者开吃
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
  }
}

public class Foodie extends Thread{

    @Override
    public void run() {
        /*
        * 1. 循环
        * 2. 同步代码块
        * 3. 判断共享数据是否到了末尾（到了末尾）
        * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
        * */

        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    //先判断桌子上是否有面条
                    if(Desk.foodFlag == 0){
                        //如果没有，就等待
                        try {
                            Desk.lock.wait();//让当前线程跟锁进行绑定
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        //把吃的总数-1
                      Desk.count--;
                        //如果有，就开吃
                        System.out.println("吃货在吃面条，还能再吃" + Desk.count + "碗！！！");
                      //吃完之后，唤醒厨师继续做
                        Desk.lock.notifyAll();
                        //修改桌子的状态
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
       /*
       *
       *    需求：完成生产者和消费者（等待唤醒机制）的代码
     *         实现线程轮流交替执行的效果
       *
       * */


        //创建线程的对象
      Cook c = new Cook();
        Foodie f = new Foodie();

        //给线程设置名字
        c.setName("厨师");
        f.setName("吃货");

        //开启线程
        c.start();
        f.start();
    }
}

3.3生产者和消费者案例优化【应用】

需求
- 将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 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 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 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.4阻塞队列基本使用【理解】

阻塞队列继承结构
常见BlockingQueue:

ArrayBlockingQueue: 底层是数组,有界

LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值
BlockingQueue的核心方法:

put(anObject): 将参数放入队列,如果队列已满时放不进去会阻塞

take(): 取出第一个数据,队列为空时取不到会阻塞

代码示例

public class Demo02 {
    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.5阻塞队列实现等待唤醒机制【理解】

案例需求
- 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
  
  1.构造方法中接收一个阻塞队列对象
  
  2.在run方法中循环向阻塞队列中添加面条
  
  3.打印添加结果
- 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
  
  1.构造方法中接收一个阻塞队列对象
  
  2.在run方法中循环获取阻塞队列中的面条
  
  3.打印获取结果
- 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
  
  创建阻塞队列对象
  
  创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象
  
  分别开启两个线程
下面的代码中阻塞队列长度设置成1，则就相当于生产一个消费一个，设置阻塞队列的长度大于1时，就不再是生产一个消费一个，就变成了阻塞队列不满就一直生产，阻塞队列不空就一直消费（当然这是没有加最多生产消费多少个的限制）

代码实现

public class Cook extends Thread{

    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true){
            //不断的把面条放到阻塞队列当中
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Foodie extends Thread{

    ArrayBlockingQueue<String> queue;

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


    @Override
    public void run() {
        while(true){
                //不断从阻塞队列中获取面条
                try {
                    String food = queue.take();
                    System.out.println(food);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
       /*
       *
       *    需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码
       *    细节：
       *           生产者和消费者必须使用同一个阻塞队列
       *
       * */

        //1.创建阻塞队列的对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);


        //2.创建线程的对象，并把阻塞队列传递过去
        Cook c = new Cook(queue);
        Foodie f = new Foodie(queue);

        //3.开启线程
        c.start();
        f.start();
    }
}

LCQ5279

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程、线程同步、生产者消费者问题

概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法方法名说明释放锁，并进入等待状态。
复制链接

扫一扫

专栏目录