跟着大佬学java第十三课，多线程详解（四）

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量88 收藏
点赞数
分类专栏： java学习 文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42681553/article/details/120526803
版权

文章目录

多线程详解

Lock锁

  1. 从 JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  2. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  3. ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语句，在实现线程安全的控制中，比较常见的是ReentrantLock，可以显式加锁、释放锁
//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    int ticketNum = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //显式加锁
                lock.lock();
                //原不加锁代码块
                if (ticketNum>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNum--);
                }else{
                    break;
                }
            }finally {
                //显式解锁
                lock.unlock();
            }
        }
    }
}

结果：
10
9
8
7
6
5
4
3
2
1

synchronized 与 Lock对比

  1. Lock是显式锁（手动开启和关闭锁，必须手动关闭），synchronized是隐式锁，出了作用域自动释放
  2. Lock只有代码块锁，synchronized有代码块锁和方法所
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
  4. 优先使用顺序：
    1. Lock > 同步代码块（已经进入了方法体，分配了相应的资源）> 同步方法（在方法体之外）

生产者消费者问题

线程通信

  1. 场景：生产者消费者问题
    1. 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费
    2. 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
    3. 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

问题分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

  1. 对于生产者，没有生产产品之前，要通知消费者等待，而生产力产品之后，又需要马上通知消费者消费
  2. 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
  3. 在生产者消费者问题中，仅有synchronized是不够的
    1. synchronized可组织并发更新同一个共享资源，实现了同步
    2. synchronized不能用来实现不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题

  1. wait()

    1. 方法名：wait()

      作用：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁

    2. 方法名：wait(long timeout)

      作用：指定等待的毫秒数

  2. notify()

    1. 方法名：notify()

      作用：唤醒一个处于等待状态的线程

    2. 方法名：notifyAll()

      作用：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常lllegalMonitorStateException

解决方式1

并发协作模式“生产者/消费者模式” —> 管程法

  1. 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
  2. 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
  3. 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

解决方式2

并发协作模型“生产者/消费者模式” —> 信号灯法

通过标志位解决问题

管程法

解决方法1实例

//测试生产者消费者模式 ---> 利用缓冲区解决：管程法
//生产者、消费者、产品、缓冲区
public class TestPC {
    
    public static void main(String[] args) {
        Syncontainer container = new Syncontainer();

        //启动线程
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者线程
class Productor extends Thread{
    Syncontainer container;

    public Productor(Syncontainer container){
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(i, new Chicken(i));
        }
    }
}

//消费者线程
class Consumer extends Thread{
    Syncontainer container;

    public Consumer(Syncontainer container){
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费第--->"+container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken{
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class Syncontainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(int i, Chicken chicken){
        //如果容器满了，就需要等待消费
        while (count == 10){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有满，就需要丢入产品
        chickens[count] = chicken;
        count++;

        //可以通知消费者消费了
        System.out.println("生产第"+i+"只鸡");
        this.notify();
    }

    public synchronized Chicken pop(){
        //判断能否消费
        while (count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //消费后通知生产者生产
        this.notify();
        return chicken;
    }
}

结果：
生产第0只鸡
生产第1只鸡
生产第2只鸡
生产第3只鸡
生产第4只鸡
生产第5只鸡
生产第6只鸡
生产第7只鸡
生产第8只鸡
生产第9只鸡
生产第10只鸡
消费第--->9只鸡
消费第--->10只鸡
生产第11只鸡
消费第--->11只鸡
生产第12只鸡
消费第--->12只鸡
生产第13只鸡
消费第--->13只鸡
生产第14只鸡
消费第--->14只鸡
生产第15只鸡
消费第--->15只鸡
生产第16只鸡
消费第--->16只鸡
……
……
……
消费第--->84只鸡
生产第85只鸡
消费第--->85只鸡
生产第86只鸡
消费第--->86只鸡
生产第87只鸡
消费第--->87只鸡
生产第88只鸡
消费第--->88只鸡
生产第89只鸡
消费第--->89只鸡
消费第--->8只鸡
消费第--->7只鸡
消费第--->6只鸡
生产第90只鸡
生产第91只鸡
生产第92只鸡
生产第93只鸡
消费第--->93只鸡
生产第94只鸡
消费第--->94只鸡
生产第95只鸡
消费第--->95只鸡
消费第--->92只鸡
消费第--->91只鸡
消费第--->90只鸡
生产第96只鸡
生产第97只鸡
生产第98只鸡
生产第99只鸡
消费第--->99只鸡
消费第--->98只鸡
消费第--->97只鸡
消费第--->96只鸡
消费第--->5只鸡
消费第--->4只鸡
消费第--->3只鸡
消费第--->2只鸡
消费第--->1只鸡
消费第--->0只鸡

主方法中启动线程，在生产者线程中，循环向缓冲区中存放100条数据，在消费者线程中，循环从缓冲区取出100条数据。

缓冲区容量为10，当前剩余为0；

通过 push 方法放入生产者线程的数据，当缓冲区中已存在10条数据时等待，若不满则继续存放数据，通知消费者线程取出数据；

通过 pop 方法取出缓冲区中的数据，当缓冲区中的数据数量为0时等待，若不为空则继续取出数据，通知生产者存入数据

信号灯法

解决方法2实例

package com.kuang.gaoji;

//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPc2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();

    }
}

//生产者 --> 演员
class Player extends Thread{
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                this.tv.play("快乐大本营播放中");
            }else{
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}

//消费者 --> 观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品 --> 节目
class TV{
    //演员表演，观众等等 T
    //观众观看，演员等待 F
    String voice; //表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+voice);
        //通知观众观看
        this.notifyAll(); //通知唤醒

        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了"+voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

结果：
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活
演员表演了快乐大本营播放中
观看了快乐大本营播放中
演员表演了抖音：记录美好生活
观看了抖音：记录美好生活

可类似看为缓冲区容量为1的线程，消费者和生产者轮流运行

线程池

  1. 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
  2. 思路：提前创建好多个线程，放入线程池汇总，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用
  3. 好处：
    1. 提高响应速度（减少了创建新线程的时间）
    2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    3. 便于线程管理
      1. corePoolSize：核心池的大小
      2. maximunPoolSize：最大线程数
      3. keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池的实例

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool  参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();
    }
}

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

结果：
pool-1-thread-1
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2

线程池的使用

  1. JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
  2. ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    1. void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    2. Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
    3. void shutdown( )：关闭连接池
  3. Executors：工具类、线程池的工厂类，用于创建并不返回类型的线程池
-达达
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习多线程使用这个笔记就够了
02-02
线程编程是Java中一个重要的概念，尤其对于大型的、高并发的应用来说，理解并掌握多线程是必不可少的。本笔记将从基础概念开始，逐步深入到高级主题，帮助你从零基础到熟练掌握Java多线程。 **1. 进程与线程** - **...
Java的各种实验包括反射，算法，多线程，面试题，springboot
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
线程同步：生产者和消费者问题
fushengfei的专栏
11-16 136
1、实现一个生产者         public class Producer implements Runnable { SyncStack stack; //数据存放位置，和生产者是相同的位置 public Producer(SyncStack s){ stack = s; } public void run(){ for(int i=0; i&lt;...
生产者消费者syn版本和Lock版本+Condition的精确通知
m0_50711251的博客
04-28 104
Condition的精确通知 /* * 题目：多线程之间按顺序来调用，实现A->B->C三个线程启动，要求如下： * AA打印5次，BB打印10次，Cc打印15次 * 。。。。。。 * 来10轮 * */ class sharedSource{ private int num=1; Lock lock= new ReentrantLock(); Condition c1 = lock.newCondition(); Condition c2 = lock..
生产者消费者模式以及两种解决方式
skz980619的博客
08-14 434
线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 线程通信—分析 这是一个线程同步的问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。 对于生产者，没有生产产品之前，要通知消费者等待，而生产
java 生产者和消费者——Synchronized方式
倒骑驴走着瞧的博客
07-07 919
/** * 生产者消费者问题： 容器最多放5个商品；当容器未装满时，生产者一直生产商品并放入容器中，当容器中有商品时，消费者就一直消费商品； 情景： * 生产者生产20个商品并被消费者消费 */ public class ProducerAndComsumerDemo { private int pruductsSum = 0; private static final int FULL = 5;//容器中最多容纳5个产品 public static void main(String[]
生产者消费者模式三种实现方式
热门推荐
weixin_38568503的博客
03-28 1万+
1.什么是生产者消费者模式： 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类。在学习一些设计模式的过程中，如果先找到
2022java面试题、JVM面试题、多线程面试题、并发编程
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
202面试题，Java面试题、JVM面试题、多线程面试题、并发编程
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
清华大佬JAVA课程-共109门课.txt
09-01
清华大佬JAVA课程-共109门课.txt
Synchronized实现生产者消费者问题
qq_45979629的博客
01-03 723
首先，我们得了解什么是生产者消费者问题 所谓的生产者消费者模型，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架满的时候，消费者可以从货架上拿走商品，生产者此时等待货架的空位，这样不断的循环。那么在这个过程中，生产者和消费者是不直接接触的，所谓的‘货架’其实就是一个阻..
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 310
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1098
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 145
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 589
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 346
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 713
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 458
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 406
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
阿里大佬Java面试资料：JVM线程及相关内容详解。
《阿里大佬总结的Java面试资料》是一份详细的Java面试资料，总结了JVM、线程等相关知识。本文将根据内容对资料进行总结，并严格要求达到2000字。 该面试资料首先介绍了目录，包括JVM、线程等主题。JVM是Java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值