ThreadLocal、单例模式、线程通讯bing

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量194 收藏
点赞数
分类专栏： 多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiqipengcheng/article/details/118153740
版权

上一篇

这里写目录标题

线程安全问题

场景：实现1000任务的时间格式化

   private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");

    public static void main(String[] args) {
        // 定义线程池
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(10, 10, 0, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(1000));
        for (int i = 1; i < 1001; i++) {
            final int finalI = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    Date date = new Date(finalI * 1000);
                    myFormatTime(date);
                }
            });
        }
    }

    private static void myFormatTime(Date date) {
        String result = simpleDateFormat.format(date);
        System.out.println("时间：" + result);
    }

结果：

在这里插入图片描述

原因：

在这里插入图片描述
异常情况：
在这里插入图片描述

解决方式修改部分代码：

1.加锁( synchronized ）

 private synchronized static void myFormatTime(Date date) {
        String result = simpleDateFormat.format(date);
        System.out.println("时间：" + result);
    }

2.私有变量

 private static void myFormatTime(Date date) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
        String result = simpleDateFormat.format(date);
        System.out.println("时间：" + result);
    }

3.ThreadLocal 一种方案既可以避免加锁排队执行，又不会每次执行任务都需要重新创建私有变量的方法

ThreadLocal线程的本地变量，每个线程创建一个私有变量，以1000个任务10个线程池的示例来说，使用ThreadLocal就是创建10 SimpleDateFormat对象。
在这里插入图片描述

基本使用
   // 创建 ThreadLocal
    private static ThreadLocal<String> threadLocal =
            new ThreadLocal<>();

    public static void main(String[] args) {
        // 定义公共任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 得到线程名称
                String tname = Thread.currentThread().getName();
                System.out.println(tname + " 设置值：" + tname);
                try {
                    // set ThreadLocal
                    threadLocal.set(tname);
                    // 执行 ThreadLocal 打印
                    printThreaLocal();
                } finally {
                    // 移除 ThreadLocal
                    threadLocal.remove();
                }
            }
        };

        Thread t1 = new Thread(runnable, "线程1");
        t1.start();

        Thread t2 = new Thread(runnable, "线程2");
        t2.start();

    }

    private static void printThreaLocal() {
        // 从 ThreadLocal 中获取值
        String result = threadLocal.get();
        System.out.println(Thread.currentThread().getName() +
                " 中取值：" + result);
    }
初始化使用
  // 创建和初始化 ThreadLocal
    private static ThreadLocal<SimpleDateFormat> threadLocal =
            new ThreadLocal() {
                @Override
                protected SimpleDateFormat initialValue() {//返回值与该类泛型化一致
                    System.out.println("执行 InitialValue 方法");
                    return new SimpleDateFormat("mm:ss");
                }
            };

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Date date = new Date(1000);
                // 从 ThreadLocal 获取 DateFormat 对象，并格式化时间
                String result = threadLocal.get().format(date);
                System.out.println("线程1 时间格式化：" + result);
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Date date = new Date(2000);
                // 从 ThreadLocal 获取 DateFormat 对象，并格式化时间
                String result = threadLocal.get().format(date);
                System.out.println("线程2 时间格式化：" + result);
            }
        });
        t2.start();
    }
线程池使用
    private static ThreadLocal<Integer> threadLocal =
            new ThreadLocal() {
                @Override
                protected Integer initialValue() {
                    int num = new Random().nextInt(10);
                    System.out.println("执行了 initialValue 生成了：" + num);
                    return num;
                }
            };

    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1,
                0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1000));

        executor.submit(new Runnable() {
            @Override
            public void run() {
                // get ThreadLocal
                int result = threadLocal.get();
                System.out.println(Thread.currentThread().getName() +
                        " 得到结果1：" + result);
            }
        });

        executor.submit(new Runnable() {
            @Override
            public void run() {
                // get ThreadLocal
                int result = threadLocal.get();
                System.out.println(Thread.currentThread().getName() +
                        " 得到结果2：" + result);
            }
        });

    }
另一种用法ThreadLocal.withInitial
  // 创建并初始化 ThreadLocal
    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(new Supplier<String>() {
                @Override
                public String get() {
                    System.out.println("执行了 withInitial 方法");
                    return Thread.currentThread().getName() + "Java";
                }
            });

    public static void main(String[] args) {

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 获取 ThreadLoal
                String result = threadLocal.get();
                System.out.println(Thread.currentThread().getName() +
                        " 获取到的内容：" + result);
            }
        };
        Thread t1 = new Thread(runnable, "线程1");
        t1.start();

        Thread t2 = new Thread(runnable, "线程2");
        t2.start();

    }

简洁版：

    private static ThreadLocal<String> threadLocal =
            ThreadLocal.withInitial(() -> "Java");
当ThreadLocal中出现set 方法之后，所有类型的初始化方法就不会执行了。

原因:ThreadLocal在执行get方法的时候，才去判断并调用初始化方法。
当调用ThreadLocal.get（）方法时
在这里插入图片描述

ThreadLocal的使用场景

在这里插入图片描述


    private static ThreadLocal<User> userThreadLocal
            = new ThreadLocal();

    /**
     * 实体类
     */
    static class User {
        private String name;

        public String getName() {
            return name;
        }

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

    public static void main(String[] args) {
        Storage storage = new Storage();
        Storage2 storage2 = new Storage2();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 用户登录
                User user = new User();
                user.setName("比特");
                userThreadLocal.set(user);

                // 打印用户的信息
                storage.printUserName3();
                storage2.printUserName3();
            }
        });
        t1.start();

    }


    class UserStrorage {

        public User getUser() {
            // 登录
            User user = new User();
            user.setName("比特");
            return user;
        }

    }

    /**
     * 仓储类
     */
    static class Storage {
//        public void printUserName(User user) {
//            System.out.println(user.getName());
//        }
//
//        public void printUserName2() {
//            System.out.println(new UserStrorage()
//                    .getUser().getName());
//        }

        public void printUserName3() {
            User user = userThreadLocal.get();
            System.out.println("用户名" + user.getName());
        }
    }

    /**
     * 类 2
     */
    static class Storage2 {
        public void printUserName3() {
            User user = userThreadLocal.get();
            System.out.println("用户名" + user.getName());
        }
    }

ThreadLocal的问题

不可继承性

在子进程里访问不到父进程的变量

解决方案

使用ThreadLocal的子类

 // 创建 ThreadLocal
    private static ThreadLocal threadLocal =
            new InheritableThreadLocal();

    public static void main(String[] args) {
        // 在主线程里面设置值
        threadLocal.set("Java");

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("获取值：" +
                        threadLocal.get());
            }
        });
        t1.start();
    }

脏读问题

在一个线程中读取到了不属于自己的信息就叫做脏读

   static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1,
                0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));

        for (int i = 0; i < 2; i++) {
            executor.submit(new MyThreadLocal());
        }

//        MyThreadLocal t1 = new MyThreadLocal();
//        t1.start();
//
//        MyThreadLocal t2 = new MyThreadLocal();
//        t2.start();
    }

    static class MyThreadLocal extends Thread {
        private static boolean flag = false;

        @Override
        public void run() {
            String tname = this.getName();
//            String tname = Thread.currentThread().getName();
            if (!flag) {
                // 第一次执行
                threadLocal.set(tname);
                System.out.println(tname + " 设置了：" + tname);
                flag = true;
            }
            System.out.println(tname + "得到了：" + threadLocal.get());
        }
    }

结果：
在这里插入图片描述
脏读产生的原因:
线程池复用了线程，和这个线程相关的静态属性也复用，所以就导致了脏读。

解决方案：

a)避免使用静态变量。
b)使用完之后，执行remove操作。（threadLocal.remove();）

内存溢出

当一个线程使用完资源之后，没有释放资源，或者说释放资源不及时就是内存溢出。（使用线程池容易出现该情况）
内存溢出的原因:
1.线程池是长声明周期。
垃圾回收器就不会回收
2.Thread -> ThreadLocalMap ->Entry key, value(1mb资源)
value资源。

在这里插入图片描述
在这里插入图片描述
ThreadLocal 会将key设置为弱引用是因为Threadlocal 为了更大程度的避免OOM

解决方案

// 创建 ThreadLocal
    private static ThreadLocal<MyThreadLocal> threadLocal =
            new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                10, 10, 0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1000)
        );
        for (int i = 0; i < 10; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        MyThreadLocal myThreadLocal = new MyThreadLocal();
                        threadLocal.set(myThreadLocal);
                        System.out.println(Thread.currentThread().getName() +
                                " 设置了值。");

                    } finally {
                        // 溢出变量（防止OOM）
                        threadLocal.remove();
                    }
                }
            });
            Thread.sleep(200);
        }


    }

    // 创建大对象
    static class MyThreadLocal {
        private byte[] bytes = new byte[1 * 1024 * 1024];
    }

ThreadLocal 和普通的Map解决哈希冲突

在这里插入图片描述

单例模式

单例模式

线程通讯（自定义阻塞队列）


    static class MyBlockingQueue {
        private int[] values; // 存放数据的数组
        private int first;    // 队首的下标
        private int last;     // 队尾的下标
        private int size;     // 实际队列大小

        /**
         * 构造方法
         * @param maxSize 最大容量
         */
        public MyBlockingQueue(int maxSize) {
            // 初始化队列
            values = new int[maxSize];
            first = 0;
            last = 0;
            size = 0;
        }

        /**
         * 添加元素（将元素添加到队尾）
         * @param val
         */
        public void offer(int val) throws InterruptedException {
            synchronized (this) {
                // 判断容量是否达到最大值
                if (size == values.length) {
                    // 阻塞等待，消费者先消费
                    this.wait();
                }
                values[last++] = val;
                size++;
                // 判断是否是最后一个元素
                if (last == values.length) {
                    // 循环队列
                    last = 0;
                }
                // 唤醒消费者取队列中的信息
                this.notify();
            }
        }

        /**
         * 取元素（队首元素）
         * @return
         */
        public int poll() throws InterruptedException {
            int result = 0;
            synchronized (this) {
                // 判断队列是否有元素
                if (size == 0) {
                    // 阻塞等待
                    this.wait();
                }
                result = values[first++];
                size--;
                // 判断 first 是否是最后一个元素
                if (first == values.length) {
                    first = 0;
                }
                // 唤醒生产者生产数据
                this.notify();
            }
            return result;
        }
    }

    public static void main(String[] args) {

        MyBlockingQueue myBlockingQueue = new MyBlockingQueue(100);

        // 生产者
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {

                // 生产数据（添加数据）
                while (true) {
                    int num = new Random().nextInt(10);
                    System.out.println("生产数据：" + num);
                    try {
                        // 生产数据
                        myBlockingQueue.offer(num);
                        // 休息 500 ms
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();

        // 消费者
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        int result = myBlockingQueue.poll();
                        System.out.println("消费数据：" + result);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start();

    }

下一篇

月屯
关注
专栏目录
Android--多个Activity共享Socket--单例模式
猪の成长日记
04-13 1843
自己跟同学校能电院同学一起做的创新训练项目： 树莓派端与app端建立Socket通信，要求app端收发信息，树莓派端处理信息。 问题：在多个Activity之间共享Socket通信，使用设计模式单例模式：单例模式保证在程序中只有一个实例存在并且能全局的访问到。 public class MSocket extends Socket{ //private static fin...
LinkedBlockingQueue 实现每秒限制N次请求
我思故我在
04-24 657
时间紧迫直接上代码 public class TestA { public static void main(String[] args) { for (int i = 0; i < 100; i++) { new Thread(() -> { while (true) { ...
高并发编程之LinkedBlockingQueue讲解
weixin_42146366的博客
02-27 3336
一、LinkedBlockingQueue介绍 ①、LinkedBlockingQueue是一个单向链表实现的阻塞队列，先进先出的顺序。支持多线程并发操作。相比于数组实现的ArrayBlockingQueue的有界，LinkedBlockingQueue可认为是无界队列。多用于任务队列。 ②、LinkedBlockingQueue不同于ArrayBlockingQueue，它如果不指定容量，默认为...
java创建线程池的4种方式之队例LinkedBlockingQueue（七）
猿起于此
08-17 1525
常用方法： 一、添加元素 1、add 方法：如果队列已满，报java.lang.IllegalStateException: Queue full 错误 2、offer 方法：如果队列已满，程序正常运行，只是不再新增元素 3、put 方法：如果队列已满，阻塞 二、取元素 1、poll 方法：弹出队顶元素，队列为空时返回null 2、peek 方法：返回队列顶元素，但顶元素不弹出，队列为空时返回nu...
LinkedBlockingQueue应用详解
wkend的博客
01-01 6109
一． 概述及应用场景 Jdk源码注释：（JDK1.9）/** 1. An optionally-bounded {@linkplain BlockingQueue blocking queue} based on 2. linked nodes. 3. This queue orders elements FIFO (first-in-first-out). 4. The <em>h
高并发编程学习(2)——线程通信详解
Java笔记虾
12-02 356
前序文章高并发编程学习(1)——并发基础 - https://www.wmyskxz.com/2019/11/26/gao-bing-fa-bian-cheng-xue-xi-1-bin...
EventBus用法全解析
hbyh632的博客
09-27 342
以下都是本人收集和总结的内容: 1. 什么是Eventbus EventBus是一个基于观察者模式的事件发布/订阅框架，开发者通过极少的代码去实现多个模块之间的通信，而不需要以层层传递接口的形式去单独构建通信桥梁。从而降低因多重回调导致的模块间强耦合，同时避免产生大量内部类。拥有使用方便，性能高，接入成本低，支持多线程的优点。 2. 如何实现Eventbus 2.1 定义事件 事件是PO
【万字长文】高并发中的线程通信，看这一篇就够了！
Java团长的博客
01-03 908
一、经典的生产者消费者案例上一篇文章我们提到一个应用可以创建多个线程去执行不同的任务，如果这些任务之间有着某种关系，那么线程之间必须能够通信来协调完成工作。生产者消费者问题（英语：Pro...
Java 单例模式线程安全问题
08-29
Java 单例模式线程安全问题详解 Java 单例模式线程安全问题是指在 Java 中实现单例模式时，如何确保线程安全的问题。单例模式是指在整个应用程序生命周期中，只有一个实例存在的设计模式。这种模式可以提高性能，...
Hibernate用ThreadLocal模式(线程局部变量模式)管理Session
08-26
总的来说，ThreadLocal模式在Hibernate中用于管理Session，解决了多线程环境下Session的共享问题，实现了线程间的隔离，提高了系统的稳定性和效率。通过合理地使用ThreadLocal，开发者可以构建出更高效、更安全的多...
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
线程唯一的单例模式，又称为线程局部单例，是指在同一个线程内保证单例的唯一性，而在不同线程之间可以有各自的实例。实现线程唯一单例通常可以通过使用`ThreadLocal`变量。`ThreadLocal`为每个线程都维护了一个独立...
Java23种设计模式--单例模式：饿汉式单例&懒汉式单例&注册式单例&ThreadLocal线程单例
OASISHzzggg的博客
02-21 659
Java23种设计模式--单例模式：饿汉式单例&懒汉式单例&注册式单例&ThreadLocal线程单例
ThreadLocal、单例模式和多线程、ConcurrentHashMap、CopyOnWrite容器
二一点
03-26 2782
什么是ThreadLocal？先看看JDK中的源码是怎样描述的：This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code s...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 435
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1285
项目功能：商品分类,商品信息,用户。
Hadoop生态圈框架部署（二）- 配置IP地址映射为主机名及免密登录
zcs2312852665的博客
10-29 1242
介绍在虚拟机hadoop1、hadoop2和hadoop3配置IP地址映射为主机名配置虚拟机hadoop1、hadoop2和hadoop3互相免密登录。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1056
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
SpringSession源码分析
lkr_lkr的博客
11-01 149
默认对常规Session的理解和使用，如何使用Set-Cookie。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1246
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
threadlocal 单例
10-15
使用 ThreadLocal 可以实现单例模式，即每个线程只会创建一个实例。这种方式可以避免多线程环境下的竞争和冲突，同时也可以提高程序的性能。 下面是一个使用 ThreadLocal 实现单例模式的示例代码： ``` public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月屯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值