线程池（二）

最新推荐文章于 2023-07-04 16:44:00 发布
最新推荐文章于 2023-07-04 16:44:00 发布
阅读量264 收藏
点赞数 2
分类专栏： JavaWeb 文章标签： 多线程 内存泄漏 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46804966/article/details/117307146
版权

文章目录

1.实现时间格式化

实现1000个日期的时间格式化

package threadpool_5_26;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo04 {
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,
                10,60, TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000));

        for (int i = 1; i < 1001; i++) {
            final int k = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    Date date = new Date(k * 1000);
                    myFormatTime(date);
                }
            });
        }
    }

    public static void myFormatTime(Date date){

        String ret = simpleDateFormat.format(date);
        System.out.println("时间："+ret);
    }
}

运行结果：
在这里插入图片描述
结果分析：

SimpleDateFormat是线程不安全的

源码如下：
在这里插入图片描述
分析：

  1. 线程 1 执⾏了 calendar.setTime(date) ⽅法，将⽤户输⼊的时间转换成了后⾯格式化时所需要的时 间；
  2. 线程 1 暂停执⾏，线程 2 得到 CPU 时间⽚开始执⾏；
  3. 线程 2 执⾏了 calendar.setTime(date) ⽅法，对时间进⾏了修改；
  4. 线程 2 暂停执⾏，线程 1 得出 CPU 时间⽚继续执⾏，因为线程 1 和线程 2 使⽤的是同⼀对象，⽽时 间已经被线程 2 修改了，所以此时当线程 1 继续执⾏的时候就会出现线程安全的问题了。

正常情况下：
在这里插入图片描述
非线程安全情况下：
在这里插入图片描述

2.解决线程不安全

2.1加锁机制（synchronized,lock）

缺点：
需要加锁排队执行，消耗时间较长

2.2使用局部变量

缺点：
每次执行任务都需要重新创建私有变量

2.3使用ThreadLocal

以1000个任务10个线程的示例来说，使用ThreadLocal就是创建10个SimpleDateFormat对象

3.ThreadLocal的基本使用

3.1五个方法
  • get（）：返回此线程局部变量的当前线程副本中的值。
  • set（T value）： 将此线程局部变量的当前线程副本中的值设置为指定值。
  • remove（）：移除此线程局部变量当前线程的值。
  • initialValue()：初始化方法，实例方法
  • withInitial：初始化方法，静态方法
3.2get，set，remove
package threadpool_5_27;

import java.util.concurrent.ThreadFactory;

public class Demo01 {

    private static ThreadLocal<String> threadLcal = 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 {
                    threadLcal.set(tname);

                    //执行ThreadLocal打印
                    printTreadLocal();
                }finally {
                    threadLcal.remove();
                }
            }
        };

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

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

    private static void printTreadLocal() {
        String ret = threadLcal.get();
        System.out.println(Thread.currentThread().getName()+" 中取值"+ret);
    }
}

运行结果：
在这里插入图片描述

3.3initialValue方法
package threadpool_5_27;

import java.util.Random;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo03 {

    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 threadPoolExecutor = new ThreadPoolExecutor(1,
                1,60, TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(1000));


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

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

运行结果：
在这里插入图片描述

3.4withInitial方法：
package threadpool_5_28;

import java.util.function.Supplier;

public class Demo01 {

    //创建并初始化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) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                String ret = threadLocal.get();
                System.out.println(ret);
            }
        },"线程1");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                String ret = threadLocal.get();
                System.out.println(ret);
            }
        });
        t2.start();
    }
}

在这里插入图片描述
面试题：ThreadLocal的初始化方法在什么情况下不执行？
答：ThreadLocal在执行get方法的时候，才会去判断并调用初始化方法

3.5使用ThreadLocal来实现1000个日期的时间格式化

代码示例：

package threadpool_5_28;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo05 {

    //创建并初始化ThreadLocal
    private static ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal(){
        @Override
        protected SimpleDateFormat initialValue() {
            System.out.println("执行了initial方法");
            return new SimpleDateFormat("mm:ss");
        }
    };

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,
                10,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000));

        for (int i = 1; i < 1001; i++) {
            int k = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    Date date = new Date(1000*k);
                    myDateTime(date);
                }
            });
        }
    }

    public static void myDateTime(Date date){
        String ret = threadLocal.get().format(date);
        System.out.println("时间："+ret);
    }
}

运行结果：
在这里插入图片描述
ThreadLocal的使用场景：
1.解决线程安全问题
2.实现线程级别的数据传递（可以实现一定程度的解耦）

4.ThreadLocal缺点

4.1不可继承性

主线程设置了值，子线程访问不了（子线程不能继承主线程的私有变量）
代码示例：

package threadpool_5_29;

public class ThreadLocalDemo01 {

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

    public static void main(String[] args) {

        threadLocal.set("Java");

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

    }
}

运行结果：

Thread-0 null

解决方案：
使用InheritableThreadLocal这个类

代码示例：

package threadpool_5_29;

public class ThreadLocalDemo02 {

    private static InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal();

    public static void main(String[] args) {

        inheritableThreadLocal.set("Java");

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" "+inheritableThreadLocal.get());
            }
        });
        t1.start();
    }
}

运行结果：

Thread-0 Java

注意事项：
即使使用InheritableThreadLocal也不能实现并列线程之间的数据传输（数据设置和获取）

4.2脏读

脏读定义：
在一个线程中读取到了不属于自己的信息
原因：
线程池复用了线程，和这个线程相关的静态属性也复用，所以导致了脏读

代码示例：

package threadpool_5_29;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo05 {

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

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

        @Override
        public void run() {
            String name = this.getName();
            if(!flag){
                threadLocal.set(name);
                System.out.println(name+" 设置了 "+name);
                flag = true;
            }
            System.out.println(name+" 得到了 "+threadLocal.get());
        }

    }

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,
                1,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(100));

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

运行结果：
在这里插入图片描述

解决方案：
1.避免使用静态变量
2.使用完之后，执行remove操作

4.3内存溢出

什么是内存溢出：
当一个线程使用完资源之后，没有释放资源，或者说释放资源不及时就是内存溢出

代码示例：

package threadpool_5_29;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo06 {

    private static ThreadLocal<MyThreadLocal> threadLocalThreadLocal = new ThreadLocal<>();

    static class MyThreadLocal{

        private byte [] bytes = new byte[1*1024*1024];
    }

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,10,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000));


        for (int i = 0; i < 5; i++) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    MyThreadLocal myThreadLocal = new MyThreadLocal();
                    threadLocalThreadLocal.set(myThreadLocal);
                    System.out.println(Thread.currentThread().getName()+" 设置了值");
                }
            });
        }
    }
}

运行结果：
在这里插入图片描述

内存溢出的原因：
1.线程池是长生命周期
2.Thread—>ThreadLocalMap—>Entry key ，value(1mb资源）（垃圾回收器就不会回收value资源）

垃圾回收可回收的资源相关的4种类型：
1.强引用：Object object = new Object（），即使发生OOM也不会进行垃圾回收
2.软引用：它的引用关系仅次于强引用。如果内存够用，那么垃圾回收器不会考虑回收此引用，将要发生此OOM的时候才会回收此引用
3.弱引用：不管内存够不够用，下一次回收都会将此引用的对象回收掉
4.虚引用：创建即回收，它可以触发一个垃圾回收的回调

为什么ThreadLocal会将key设置为弱引用？
答：为了最大程度的避免OOM

内存溢出解决方法：
调用remove方法

package threadpool_5_29;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalDemo08 {

    private static ThreadLocal<MyThreadLocal> threadLocalThreadLocal = new ThreadLocal<>();

    static class MyThreadLocal{

        private byte [] bytes = new byte[1*1024*1024];
    }

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,10,
                0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000));


        for (int i = 0; i < 5; i++) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try{
                        MyThreadLocal myThreadLocal = new MyThreadLocal();
                        threadLocalThreadLocal.set(myThreadLocal);
                        System.out.println(Thread.currentThread().getName()+" 设置了值");
                    }finally {
                        //移除变量，防止OOM
                        threadLocalThreadLocal.remove();
                    }

                }
            });
        }
    }
}

运行结果：
在这里插入图片描述

5.链表与红黑树

HashMap与ThreadLocalMap解决冲突：
HashMap：链表法（链表+红黑树）
ThreadLocalMap：开放寻址法

链表升级为红黑树的条件：
（1）链表长度大于8
（2）数组长度大于64

红黑树降级为链表：
链表长度小于6

为什么从链表升级为红黑树
加速查询性能

星光_依旧灿烂
关注
专栏目录
线程池详解：线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小
小小鱼儿小小林的博客
03-19 9125
线程池是一种用于管理和复用线程的机制，它允许我们在需要执行一些并发任务时，可以重复使用已经创建好的线程，而不是每次都创建新的线程。这样可以减少线程创建和销毁的开销，提高系统的性能和响应速度。并发线程池的优点包括： 提高系统的性能和吞吐量，因为可以重复使用已经创建好的线程，减少线程创建和销毁的开销。 可以控制并发任务的执行顺序和数量，从而避免系统资源被过度占用。 可以设置线程池的参数，如核心线程数、最大线程数、任务队列等，以满足不同场景的需求。
Ruby线程池
melin1204的博客
01-16 630
This is useful for a variety of scenarios. You create a thread pool, give it a maximum size, and pass a block to it everytime you need something processed. If all threads are busy, you block until a t...
ruby 线程
压碎起重机
06-15 1303
1.创建线程     ruby使用在Thread.new创建线程，线程创建后立即返回，线程也同时开始执行。ruby线程可以在创建块中使用外部变量，也可以使用本地变量，值变量在线程内部保存的是本地副本，而引用变量保存的是一个本地引用。       新线程中保存num的副本，在线程中更改num并不影响外部num值，而新线程对book的修改会直接影响外部book，在新线程中也可打破作
Ruby编程线程池案例二详解
临风暖阳的博客
07-04 92
本例可以观察到线程池tg.freeze前后的状态
ruby多线程_Ruby中的多线程
cumubi7552的博客
08-01 443
ruby多线程 Ruby多线程 (Ruby Multithreading) If we talk about a normal program in Ruby, all statements are executed sequentially because it used to have a single thread commonly known as the main thread. But...
ruby多线程理解
weixin_34122548的博客
01-09 118
2019独角兽企业重金招聘Python工程师标准>>> ...
多线程七（线程池二）
qq_54850622的博客
05-23 347
文章目录线程：线程池的优点线程池7种创建方式:方法七：原始创建线程池的方法ThreadPoolExecutor参数：线程池拒绝策略：自定义拒绝策略+JDK四种策略1默认拒绝策略，不执行任务，抛出异常标题2.使用调用者线程来执行任务（使用主线程来执行任务）3.忽略最新任务（不会报错）4.忽略老任务线程池执行流程线程池的两种执行方式：execute和submit的区别线程池的关闭：线程池的状态：总结重点： 线程： 1.线程创建需要开辟一定的内存空间（本地方法栈，虚拟栈，程序计数器）性能开销。 2.当任务量比较大
java 线程池封装_JAVA线程池及公共线程池的实现
weixin_30025473的博客
02-13 1400
一、为什么要使用线程池1、线程池比单线程的好处a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。c. 提供定时执行、定期执行、单线程、并发数控制等功能。2、使用场景(1)当你的任务是非必要的时候。比如记录操作日志、通知第三方服务非必要信息等，可以使用线程池处理非阻塞任务(2)当你的任务非常耗时时候，可以采用...
C++实现线程池详解（基于boost源码以及封装等线程池）
最新发布
10-15
二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、后进先出、优先级代码示例 五、看看人家线程池...
Java concurrency线程池之线程池原理(二)_动力节点Java学院整理
08-30
Java并发编程中的线程池是高效管理并发任务的关键工具，它可以帮助我们优化系统资源的使用，避免过度创建和销毁线程导致的性能开销。在Java中，`java.util.concurrent`包提供了`ExecutorService`接口及其实现类`...
初次接触ruby线程
Work Hard, Play Harder!
07-28 3209
第一次写一个ruby多线程程序。但是最初有点小问题 源码： i=1 puts "hello thread" puts Time.new #round=5 #while i<round # puts "the #{i}th round" # i=i+1 #end thread1=Thread.start 10 do |value| while i<value puts "#{i}"
Java线程池的管理和控制
汪涛的专栏
07-30 693
1、ExecutorService 线程池的接口为java.util.concurrent.ExecutorService，里面的方法行为约定如下： void shutdown() 发起一个有序的停止，先前已经提交的任务会被执行，并拒绝提交新的任务。 重复调用shutdown不会有副作用，遵从幂等性原则。 该方法立即返回，不会等待先前提交的任务执行完成，应该使用awaitTermination方法去等待已提交任务执行完成。 List<Runnable> shutdownNow() 试图
线程池,线程池常见的几种用法
crg18438610577的博客
11-19 670
线程池 线程池解决的问题:频繁的创建线程对象和多个线程之间进行上下文切换,是非常耗费时间和资源的,所以jdk1.5中提出了线程池技术同时能够更方便的管理线程 创建固定数量的线程 ExecutorService pool = Executors.newFixedThreadPool(2); Runnable task = new Runnable() { @Override ...
线程池
jue6628的博客
10-11 134
一、为什么要用线程池 1、频繁的创建、启动、关闭线程消耗大量的系统资源 2、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行； 3、方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。 4、提供更强大的功能，延时定时线程池。 详情 参考 ...
java多线程：ThreadPoolExecutor几个重要方法的详解
zhaoliubao1的博客
11-11 2967
1.shutdown()方法： Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.Invocation has no additional effect if already shut down.（启动有序关闭，在该关闭...
Java线程池实验：ArrayBlockingQueue和LinkedBlockingQueue吞吐量测试
trigger的博客
05-12 1010
二者区别 ArrayBlockingQueue内部使用1个锁来控制队列项的插入、取出操作，而LinkedBlockingQueue则是使用了2个锁来控制，一个名为putLock，另一个是takeLock，但是锁的本质都是ReentrantLock。 Array里面使用的时一个锁，不管put还是take行为，都可能被这个锁卡住，而Linked里面put和take是两个锁，put只会被put行为卡住，而不会被take卡住，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，因此吞吐性能自然强
Java线程池队列LinkedBlockingDeque的详细原理分析-刘宇
刘宇的博客
08-20 1905
作者：刘宇。一、 什么是LinkedBlockingDeque？二、LinkedBlockingDeque类的关系图三、BlockingDeque介绍四、LinkedBlockingDeque源码解析1、字段解析2、入队操作2.1、putFirst方法2.2、offerFirst方法2.3、入队的具体实现2.4、入队图解3、出队操作3.1、takeLast方法3.2、pollLast方法3.3、出队的具体实现3.4、出队图解五、总结。LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列。
Java并发编程之LinkedBlockingDeque阻塞队列详解
热门推荐
Stay Hungry, Stay Foolish
06-06 2万+
简介LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以l...
java线程池移除线程_Java线程池ThreadPoolExecutor中workers.remove(w)疑惑
weixin_39989443的博客
02-27 1114
在查看Java线程池实现的源码时，对于线程池内部worker生命周期有一个不解的地方：当worker所持有的task，或者线程队列中的task都被执行完以后，为什么worker要被移除线程池的worker集合。追踪源码的过程大致是：查看execute(Runnable command)方法，发现了addWorker(command, true)的调用int c = ctl.get();if (wo...
Java自带线程池ThreadPoolExecutor深度解析
二、线程池的核心类 在Java中，`java.util.concurrent`包提供了线程池相关的类，其中最重要的就是`ThreadPoolExecutor`。这个类允许开发者自定义线程池的工作逻辑，包括核心线程数、最大线程数、任务队列、线程超时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值