线程相关--笔记三

已于 2022-08-18 20:03:10 修改
阅读量74 收藏
点赞数 5
文章标签： java jvm 开发语言
于 2022-08-18 19:59:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45866765/article/details/126412612
版权

目录

等待和通知机制

生产者消费者模式

 使用synchronized实现

 使用Lock实现

阻塞队列

使用阻塞队列实现

ThreadLocal

 使用ThreadLocal

ThreadLocal的原理

等待和通知机制

锁对象：

  • 同步方法

    • 静态方法 ： 类.class

    • 实例方法： this

    同步代码块

    写在synchronized括号中的对象

可以通过锁对象调用Object类的方法：

  • wait() 让当前线程等待，直到被通知

  • wait(long) 让线程等待，直到被通知或时间结束

  • notify() 随机唤醒一个线程

  • notifyAll() 唤醒所有线程

注意：如果不是锁对象调用上面的方法会出现异常IllegalMonitorStateException

/**
 * 等待和通知案例
 */
public class WaitDemo {

    //测试等待
    public synchronized void testWait(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
            if(i == 5){
                System.out.println(Thread.currentThread().getName()+"进行等待");
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //测试通知
    public synchronized void testNotify(){
        this.notifyAll();
    }

    public static void main(String[] args) {
        WaitDemo demo = new WaitDemo();
        //启动线程测试等待
        for(int i = 0;i < 5;i++) {
            new Thread(() -> {
                demo.testWait();
            }).start();
        }
        //5秒后主线程通知
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        demo.testNotify();
    }
}

相关问题：

线程的交替输出，线程1负责输出A，线程2负责输出B，两个线程同时执行打印出ABABAB....

public class PrintDemo {

    public static synchronized void printA(){
        while(true){
            //通知对方
            PrintDemo.class.notify();
            System.out.println("A");
            //自己等待
            try {
                PrintDemo.class.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static synchronized void printB(){
        while(true){
            //通知对方
            PrintDemo.class.notify();
            System.out.println("B");
            //自己等待
            try {
                PrintDemo.class.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new Thread(()->printA()).start();
        new Thread(()->printB()).start();
    }
}

生产者消费者模式

       是一种设计模式，用于解决两个点（线程、进程、服务器）之间数据通信的协调问题。

       生产数据的点叫生产者，使用数据的点叫消费者，生产者和消费者可能存在速度不一致的情况。生产者速度过快，消费者消费速度慢，会浪费大量资源；反过来，消费者速度快，生产者速度慢，消费者浪费时间取等待。

 

过程：

  1. 设置缓冲区，设定临界值

  2. 生产者生产数据，存入缓冲区，如果缓冲区达到临界值，生产者就等待；否则就通知消费者进行消费

  3. 消费者从缓冲区取出数据，如果缓冲区空了，消费者等待；否则就通知生产者继续生产

解决的问题：

1. 解耦，生产者和消费者之间加入缓冲区，不需要直接调用
2. 忙闲不均，协调生产者和消费者之间的速度
3. 节约资源，减少生产者资源的浪费，和消费者等待的时间

 使用synchronized实现


/**
 * 包子类
 */
public class Baozi {

    private int id;

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

    @Override
    public String toString() {
        return "包子 id:" + id;
    }
}


/**
 * 包子铺
 */
public class BaoziStore {

    //临界值
    public static final int MAX_SIZE = 50;
    //缓冲区
    private List<Baozi> baozis = new ArrayList<>();

    //做包子
    public synchronized void makeBaozi(){
        //如果缓冲区满了，生产者等待
        if(baozis.size() == MAX_SIZE){
            System.out.println("包子铺满了，生产者"+Thread.currentThread().getName()+"等待");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            //通知所有消费者
            this.notifyAll();
        }
        if(baozis.size() < MAX_SIZE) {
            //创建包子对象，存入缓冲区
            Baozi baozi = new Baozi(baozis.size());
            baozis.add(baozi);
            System.out.println("生产者" + Thread.currentThread().getName() + "做了" + baozi + ",总数：" + baozis.size());
        }
    }

    //拿包子
    public synchronized void takeBaozi(){
        //如果缓冲区空了，消费者等待
        if(baozis.size() == 0){
            System.out.println("包子铺空了，消费者"+Thread.currentThread().getName()+"等待");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            //通知生产者生产
            this.notifyAll();
        }
        if(baozis.size() > 0){
            //从缓冲区拿出一个包子
            Baozi baozi = baozis.remove(0);
            System.out.println("消费者" + Thread.currentThread().getName() + "拿了" + baozi + ",总数：" + baozis.size());
        }
    }

    public static void main(String[] args) {
        BaoziStore store = new BaoziStore();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                store.makeBaozi();
            }
        }).start();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 10; j++) {
                    store.takeBaozi();
                }
            }).start();
        }
    }
}

 使用Lock实现

Lock的等待和通知

Condition 类可以提供锁对象类似的方法

创建：

Condition condition = lock.newCondition();

等待和通知：

await() 让线程等待

signal() 通知线程

signalAll() 通知所有线程

/**
 * 包子铺
 */
public class BaoziStore2 {

    //创建锁对象
    private Lock lock = new ReentrantLock();
    //获得Condition对象
    private Condition condition = lock.newCondition();
    //临界值
    public static final int MAX_SIZE = 50;
    //缓冲区
    private List<Baozi> baozis = new ArrayList<>();

    //做包子
    public void makeBaozi(){
        try {
            //上锁
            lock.lock();
            //如果缓冲区满了，生产者等待
            if (baozis.size() == MAX_SIZE) {
                System.out.println("包子铺满了，生产者" + Thread.currentThread().getName() + "等待");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                //通知所有消费者
                condition.signalAll();
            }
            if (baozis.size() < MAX_SIZE) {
                //创建包子对象，存入缓冲区
                Baozi baozi = new Baozi(baozis.size());
                baozis.add(baozi);
                System.out.println("生产者" + Thread.currentThread().getName() + "做了" + baozi + ",总数：" + baozis.size());
            }
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    //拿包子
    public void takeBaozi(){
        try {
            lock.lock();
            //如果缓冲区空了，消费者等待
            if (baozis.size() == 0) {
                System.out.println("包子铺空了，消费者" + Thread.currentThread().getName() + "等待");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                //通知生产者生产
                condition.signalAll();
            }
            if (baozis.size() > 0) {
                //从缓冲区拿出一个包子
                Baozi baozi = baozis.remove(0);
                System.out.println("消费者" + Thread.currentThread().getName() + "拿了" + baozi + ",总数：" + baozis.size());
            }
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        BaoziStore2 store = new BaoziStore2();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                store.makeBaozi();
            }
        }).start();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 10; j++) {
                    store.takeBaozi();
                }
            }).start();
        }
    }
}

阻塞队列

是一种特殊的集合，会自动阻塞对队列添加或删除数据的线程，也可以自动通知

BlockingQueue接口

put(T) 添加数据到队尾，到临界值阻塞

T take 从队头取出并删除数据，到空时阻塞

常用实现类：

ArrayBlockingQueue 数组结构的阻塞队列

LinkedBlockingQueue 链表结构的阻塞队列

SynchronousQueue 同步机制的队列

 //创建阻塞队列 临界值为5
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
        new Thread(()->{
            for(int i = 0;i < 100;i++){
                System.out.println(Thread.currentThread().getName()+"添加"+i+"，size:" + queue.size());
                try {
                    queue.put(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(()->{
            for(int i = 0;i < 100;i++){
                try {
                    Integer data = queue.take();
                    System.out.println(Thread.currentThread().getName()+"取出"+data+",size:" + queue.size());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

使用阻塞队列实现

/**
 * 包子铺
 */
public class BaoziStore3 {

    //临界值
    public static final int MAX_SIZE = 50;
    //缓冲区 使用阻塞队列实现
    private BlockingQueue<Baozi> baozis = new ArrayBlockingQueue<>(MAX_SIZE);

    //做包子
    public void makeBaozi(){
        //创建包子对象，存入缓冲区
        try {
            Baozi baozi = new Baozi(baozis.size());
            baozis.put(baozi);
            System.out.println("生产者" + Thread.currentThread().getName() + "做了" + baozi + ",总数：" + baozis.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //拿包子
    public void takeBaozi(){
        //从缓冲区拿出一个包子
        try {
            Baozi baozi = baozis.take();
            System.out.println("消费者" + Thread.currentThread().getName() + "拿了" + baozi + ",总数：" + baozis.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        BaoziStore3 store = new BaoziStore3();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                store.makeBaozi();
            }
        }).start();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 10; j++) {
                    store.takeBaozi();
                }
            }).start();
        }
    }
}

ThreadLocal

线程局部变量，也是解决线程同步问题的一种方式

锁机制 多个线程排队访问一个资源 以时间换空间 

ThreadLocal 多个线程并发访问自己独立的资源 以空间换时间

 使用ThreadLocal

public class ThreadLocalDemo {

    //线程共享的变量
    static volatile int value = 1;

    public static void main(String[] args) {
        //线程本地变量
        ThreadLocal<Integer> local = new ThreadLocal<Integer>(){
            //设置初始值
            @Override
            protected Integer initialValue() {
                return 1;
            }
        };
        for(int j = 0;j < 3;j++) {
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    value++;
                    local.set(local.get() + 1);
                }
                System.out.println(Thread.currentThread().getName()+" value=" + value);
                System.out.println(Thread.currentThread().getName()+" local=" + local.get());
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" value="+value);
        System.out.println(Thread.currentThread().getName()+" local="+local.get());
    }
}

ThreadLocal的原理

每个线程内部有Map集合ThreadLocalMap，获得数据时候返回当前线程的ThreadLocalMap，Map中有大量键值对Entry，键是当前的ThreadLocal对象，值是保存的数据。

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

相关问题

强软弱虚引用

强引用： 一般情况下创建的对象

               Person person = new Person()

               如果对象有引用指向，就不会被垃圾收集，没有引用指向就可能被垃圾收集

               person = null;

软引用： SoftReference

               如果即将出现OOM，gc会优先回收软引用，比强引用更容易被回收

               主要用于缓存

弱引用：WeakReference

               只要出现gc，都会进行回收

               可以缓存临时数据

虚引用： PhantomReference

              形同虚设，不能作为对象的引用使用，主要用于跟踪垃圾收集器的活动

强引用 > 软引用 > 弱引用 > 虚引用

- Oliver
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程笔记--顺序执行
2010yhh
05-26 1491
java多线程笔记–多线程顺序执行 文章目录java多线程笔记--多线程顺序执行1.java多线程笔记--顺序执行2.java多线程笔记--循环顺序打印问题2.1通过Lock、3个Condition的等待唤醒机制和状态变量判断，来控制3个线程输出顺序2.2通过Lock和状态变量判断，来控制3个线程输出顺序2.3通过3个信号量，每个信号量的最大许可为1，来控制3个输出顺序2.4通过Atomic原子自...
RT-Thread学习笔记——线程管理
Sanjay_Wu的博客
01-23 5013
前言 本文主要讲RT-Thread的线程管理，基于STM32L475VET5。学习RT-Thread的线程管理，实现线程的创建、多线程创建，线程的挂起与恢复等，过程中会涉及核对象容器概念，读者如果对RT-Thread的对象容器不了解，可先看《RT-Thread编程指南》的内核基础部分。 一、RT-Thread线程管理的功能特点 RT-Thread 线程管理的主要功能是对线程进行管理和调...
多线程详解--狂神笔记
xiaososa的博客
12-07 358
多线程详解 一、Process和Thread 说去进程，不得不说下程序。程序和指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位 通常在一个进程中可以包含若干线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位。 1. 注意： 很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码
java线程--Java笔记
m0_57638904的博客
12-27 268
线程 进程：指运行中的程序，进程是程序的一次执行过程（正在运行的一个程序） 线程：线程由进程创建，一个进程可以拥有多个线程 ①.单线程：同一个时刻，只执行一个线程 ②.多线程：同一个时刻，执行多个线程（同时下载歌曲、视频） ③.并发：同一个时刻，多个线程交替执行（开车时打电话，其实是大脑在切换） ④.并行：同一个时刻，多个线程同时执行（一边上厕所一边玩手机） 一.线程的使用 1.继承 Thread 类，重写 run（） 方法 一个类继承Thread 类，该类就可以当作线程使用，重写..
码农翻身之我是一个线程 --- 读书笔记
轻狂書生的博客
11-05 1284
码农翻身之我是一个线程 1. &amp;amp;quot;我&amp;amp;quot;的宿命 ----&amp;amp;amp;gt; 处理包裹 计算机世界规则 不知何时被选中执行任务 执行过程中随时可能被打断 有硬盘、数据库等耗时操作需要让出CPU等待 数据来了也得等CPU挑选 &amp;amp;quot;我&amp;amp;quot;的处理流程图 2. &amp;amp;quot;我&amp;amp;quot;的小伙
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 16万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java黑马程序员-多线程笔记
luohanisme的博客
10-17 955
哔哩哔哩java黑马视频笔记
RT-thread学习笔记之线程切换
发呆健将的博客
08-31 1366
年初的时候学习的RT-thread，时间久了有些东西都又忘了，这里记录一下自己的学习笔记方便回顾，请参考RT-thread的官方编程指南，里面讲解的其实很详细。 RT-thread在Cortex-M内核中是通过人为触发PendSV异常中断进行线程切换的，若在中断中触发PendSV异常，那么PendSV响应将在所有中断结束后进行，其实很多芯片内核都有PendSV异常中断用于操作系统线程切换； ...
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
qq_35716689的博客
03-20 16万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
RT-thread笔记--线程创建详解
qq_43745917的博客
09-10 1447
众所周知RT-Thread 操作系统的线程当中，一共有两种--静态线程和是动态线程，而RT-Thread 中的线程一般由三部分组成：线程代码（函数）、 线程控制块、 线程堆栈 那线程的创建又是怎么实现的呢？ 首先咱们先看一下静态线程的创建，代码是这样的： rt_err_t rt_thread_init(struct rt_thread* thread, ...
Linux多线程-相关手写笔记
02-06
本篇笔记将深入探讨线程的概念、线程的控制以及线程安全问题。 ### 线程概念 线程是操作系统分配处理器时间的基本单元，它与进程类似，但比进程更轻量级。在一个进程中，可以有多个线程共享同一地址空间，这意味着...
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
JAVA并发编程实践-线程执行-学习笔记
07-21
占式线程调度是Java和大多数现代操作系统采用的线程调度策略。在这种模式下，操作系统决定何时以及哪个线程将获得CPU的执行时间。线程的执行不是由线程自身控制，而是由操作系统通过时间片轮转或者优先级调度等方式...
io进程线程-进程（笔记）
04-12
进程的思维导图
NXP-RT Thread-2019培训课程-多线程编程-教程与笔记习题
05-19
NXP-RT Thread-2019培训课程-多线程编程
golang 接口
m0_70982551的博客
07-24 869
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 454
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 542
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 471
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值