11.线程系列- 线程池

最新推荐文章于 2022-11-22 20:45:04 发布
最新推荐文章于 2022-11-22 20:45:04 发布
阅读量267 收藏
点赞数
分类专栏： thread 文章标签： 多线程
原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933151&idx=1&sn=2020066b974b5f4c0823abd419e8adae&chksm=88621b21bf159237bdacfb47bd1a344f7123aabc25e3607e78d936dd554412edce5dd825003d&scene=178&cur_album_id=1318984626890915841#rd
版权

什么是线程池

大家用jdbc操作过数据库应该知道，操作数据库需要和数据库建立连接，拿到连接之后才能操作数据库，用完之后销毁。数据库连接的创建和销毁其实是比较耗时的，真正和业务相关的操作耗时是比较短的。每个数据库操作之前都需要创建连接，为了提升系统性能，后来出现了数据库连接池，系统启动的时候，先创建很多连接放在池子里面，使用的时候，直接从连接池中获取一个，使用完毕之后返回到池子里面，继续给其他需要者使用，这其中就省去创建连接的时间，从而提升了系统整体的性能。

线程池和数据库连接池的原理也差不多，创建线程去处理业务，可能创建线程的时间比处理业务的时间还长一些，如果系统能够提前为我们创建好线程，我们需要的时候直接拿来使用，用完之后不是直接将其关闭，而是将其返回到线程中中，给其他需要这使用，这样直接节省了创建和销毁的时间，提升了系统的性能。

简单的说，在使用了线程池之后，创建线程变成了从线程池中获取一个空闲的线程，然后使用，关闭线程变成了将线程归还到线程池。

线程池实现原理

当向线程池提交一个任务之后，线程池的处理流程如下：

  1. 判断是否达到核心线程数，若未达到，则直接创建新的线程处理当前传入的任务，否则进入下个流程
  2. 线程池中的工作队列是否已满，若未满，则将任务丢入工作队列中先存着等待处理，否则进入下个流程
  3. 是否达到最大线程数，若未到达，则创建新的线程处理当前出入的任务，否则交给线程池中的饱和策略进行处理

流程如下：

举个例子：

咱们作为开发者，上面都有开发主管，主管下面带领几个小弟干活，CTO给主管授权说，你可以招聘5个小弟干活，新来任务，如果小弟还不到吴哥，立即去招聘一个来干这个新来的任务，当5个小弟都招来了，再来任务之后，将任务记录到一个表格中，表格中最多记录100个，小弟们会主动去表格中获取任务执行，如果5个小弟都在干活，并且表格中也记录满了，那你可以将小弟扩充到20个，如果20个小弟都在干活，并且存放任务的表也满了，产品经理再来任务后，是直接拒绝，还是让产品自己干，这个由你自己决定，小弟们都尽心尽力在干活，任务都被处理完了，突然公司业绩下滑，几个员工没事干，打酱油，为了节约成本，CTO主管把小弟控制到5人，其他15个人直接被干掉了。所以作为小弟们，别让自己闲着，多干活。

原理：先找几个人干活，大家都忙于干活，任务太多可以排期，排期的任务太多了，再招一些人来干活，最后干活的和排期都达到上层领导要求的上限了，那需要采取一些其他策略进行处理了。对于长时间不干活的人，考虑将其开掉，节约资源和成本。

java中的线程池

jdk中提供了线程池的具体实现，实现类是

java.util.concurrent.ThreadPoolExecutor

主要构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize：核心线程大小，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使有其他空闲线程可以处理任务也会创新线程，等到工作的线程数大于核心线程数时就不会在创建了。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前把核心线程都创造好，并启动

maximumPoolSize：线程池允许创建的最大线程数。如果队列满了，并且以创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。如果我们使用了无界队列，那么所有的任务会加入队列，这个参数就没有什么效果了

keepAliveTime：线程池的工作线程空闲后，保持存活的时间。如果没有任务处理了，有些线程会空闲，空闲的时间超过了这个值，会被回收掉。如果任务很多，并且每个任务的执行时间比较短，避免线程重复创建和回收，可以调大这个时间，提高线程的利用率

unit：keepAliveTIme的时间单位，可以选择的单位有天、小时、分钟、毫秒、微妙、千分之一毫秒和纳秒。类型是一个枚举java.util.concurrent.TimeUnit，这个枚举也经常使用，有兴趣的可以看一下其源码

workQueue：工作队列，用于缓存待处理任务的阻塞队列，常见的有4种，本文后面有介绍

threadFactory：线程池中创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字

handler：饱和策略，当线程池无法处理新来的任务了，那么需要提供一种策略处理提交的新任务，默认有4种策略，文章后面会提到

调用线程池的execute方法处理任务，执行execute方法的过程:

  1. 判断线程池中运行的线程数是否小于corepoolsize，是：则创建新的线程来处理任务，否执行下一步
  2. 试图将任务添加到workQueue指定的队列中，如果无法添加到队列中，进入下一步
  3. 判断线程池中运行的线程数是否maximumPoolSize，是：则新增线程处理当前传入的任务，否：将任务传递给handler对象rejectedExecution方法处理

线程池的使用步骤：

  1. 调用构造方法创建线程池
  2. 调用线程池的方法处理任务
  3. 关闭线程池

线程池使用的简单案列

public class ThreadPool1 {

    static ThreadPoolExecutor executor = new ThreadPoolExecutor(3,5,10,
            TimeUnit.MINUTES,new ArrayBlockingQueue<Runnable>(5), Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            long j = i+ 1;
            String job = "任务" + i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(j);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "开始工作,"+ job);
                }
            });
        }
        executor.shutdown();
    }
}

运行结果：

pool-1-thread-1开始工作,任务0
pool-1-thread-2开始工作,任务1
pool-1-thread-3开始工作,任务2
pool-1-thread-1开始工作,任务3
pool-1-thread-2开始工作,任务4
pool-1-thread-4开始工作,任务8
pool-1-thread-3开始工作,任务5
pool-1-thread-5开始工作,任务9
pool-1-thread-1开始工作,任务6
pool-1-thread-2开始工作,任务7
Disconnected from the target VM, address: '127.0.0.1:64137', transport: 'socket'

Process finished with exit code 0

线程池中常见5中工作队列

任务太多的时候，工作队列用于暂时缓存待处理的任务，jdk中常见的5中阻塞队列：

ArrayBlockingQueue：是一个基于链表数组结构的有界阻塞队列，此队列按照先进先出原则对元素进行排序

LinkedBlockingQueue：是一个基于链表结构的阻塞队列，此队列按照先进先出排序原色，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool使用了这个队列

SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等到另外一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用这个队列

PriorityBlockingQueue：优先级队列，进入队列的元素按照优先级会进行排序

这里我们主要说后面两种队列

SynchronousQueue队列的线程池

public class ThreadPool2 {

    static ExecutorService executor = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            long j = i;
            String job = "任务" + i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(j);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "开始工作,"+ job);
                }
            });
        }
        executor.shutdown();
    }
}

运行结果：

pool-1-thread-1开始工作,任务0
pool-1-thread-2开始工作,任务1
pool-1-thread-3开始工作,任务2
pool-1-thread-4开始工作,任务3
pool-1-thread-5开始工作,任务4
pool-1-thread-6开始工作,任务5
pool-1-thread-1开始工作,任务6
pool-1-thread-7开始工作,任务7
pool-1-thread-8开始工作,任务8
pool-1-thread-9开始工作,任务9

代码中使用Executors.newCachedThreadPool()创建线程池，看一下的源码：

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

从输出中可以看出，系统创建了10个线程处理任务，代码中使用了SynchronousQueue同步队列，这种队列比较特殊，放入元素必须要有另外一个线程去获取这个元素，否则放入元素会失败或者一直阻塞在那里直到有线程取走，示例中任务处理休眠了一定的时间，导致已创建的工作线程都忙于处理任务，所以新来任务之后，将任务丢入同步队列会失败，丢入队列失败之后，会尝试新建线程处理任务。使用上面的方式创建线程池需要注意，如果需要处理的任务比较耗时，会导致新来的任务都会创建新的线程进行处理，可能会导致创建非常多的线程，最终耗尽系统资源，触发OOM。

PriorityBlockingQueue优先级队列的线程池

public class ThreadPool3 implements Runnable, Comparable<ThreadPool3> {

    private int i;
    private String name;

    ThreadPool3(int i, String name) {
        this.i = i;
        this.name = name;
    }

    static ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10,
            TimeUnit.SECONDS, new PriorityBlockingQueue<>(), Executors.defaultThreadFactory());

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            String taskName = "任务" + i;
            executor.execute(new ThreadPool3(i, taskName));
        }
        for (int i = 100; i > 90; i--) {
            String taskName = "任务" + i;
            executor.execute(new ThreadPool3(i, taskName));
        }
        executor.shutdown();
    }

    @Override
    public int compareTo(ThreadPool3 o) {
        return Integer.compare(o.i, i);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "工作 " + this.name);
    }
}

运行结果：

pool-1-thread-1工作 任务0
pool-1-thread-1工作 任务100
pool-1-thread-1工作 任务99
pool-1-thread-1工作 任务98
pool-1-thread-1工作 任务97
pool-1-thread-1工作 任务96
pool-1-thread-1工作 任务95
pool-1-thread-1工作 任务94
pool-1-thread-1工作 任务93
pool-1-thread-1工作 任务92
pool-1-thread-1工作 任务91
pool-1-thread-1工作 任务9
pool-1-thread-1工作 任务8
pool-1-thread-1工作 任务7
pool-1-thread-1工作 任务6
pool-1-thread-1工作 任务5
pool-1-thread-1工作 任务4
pool-1-thread-1工作 任务3
pool-1-thread-1工作 任务2
pool-1-thread-1工作 任务1

输出中，除了第一个任务，其他任务按照优先级高低按顺序处理。原因在于：创建线程池的时候使用了优先级队列，进入队列中的任务会进行排序，任务的先后顺序由i变量决定。向PriorityBlockingQueue加入元素的时候，内部会调用代码中Task的compareTo方法决定元素的先后顺序。

自定义创建线程的工厂

给线程池中线程起一个有意义的名字，在系统出现问题的时候，通过线程堆栈信息可以更容易发现系统中问题所在。自定义创建工厂需要实现java.util.concurrent.ThreadFactory接口中的Thread newThread(Runnable r)方法，参数为传入的任务，需要返回一个工作线程。

public class ThreadPool4{

    static AtomicInteger threadNum = new AtomicInteger(1);

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5, 10,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), r -> {
            Thread thread = new Thread(r);
            thread.setName("自定义线程-" + threadNum.getAndIncrement());
            return thread;
        });
        for (int i = 0; i < 5; i++) {
            String taskName = "任务-" + i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
            });
        }
        executor.shutdown();
    }


}

输出：

自定义线程-1处理任务-0
自定义线程-3处理任务-2
自定义线程-2处理任务-1
自定义线程-4处理任务-3
自定义线程-5处理任务-4

代码中在任务中输出了当前线程的名称，可以看到是我们自定义的名称。

4中常见的饱和策略

当线程池中队列已满，并且线程池已达到最大线程数，线程池会将任务传递给饱和策略进行处理。这些策略都实现了RejectedExecutionHandler接口。接口中有个方法：

 void rejectedExecution(Runnable r, ThreadPoolExecutor executor);

jdk中提供了4种常见的饱和策略：

AbortPolicy：直接抛出异常

CallerRunsPolicy：在当前调用者的线程中运行任务，谁丢来的任务，谁去处理

DiscardOldestPolicy：丢弃队列中最老的任务。

DiscardPolicy：不处理，直接丢掉

自定义饱和策略

需要实现RejectedExecutionHandler接口。任务无法处理的时候，我们想几率一下日志，我们需要自定义一个饱和策略：

public class ThreadPool5 {


    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 10,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("无法处理的任务：" + r.toString());
            }
        });
        for (int i = 0; i < 10; i++) {
            String taskName = "任务-" + i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
            });
        }
        executor.shutdown();
    }


}

运行结果：

pool-1-thread-1处理任务-0
pool-1-thread-2处理任务-6
无法处理的任务：com.example.thread.threadPool.ThreadPool5$$Lambda$1/1809787067@4c203ea1
pool-1-thread-2处理任务-2
pool-1-thread-1处理任务-1
pool-1-thread-2处理任务-3
pool-1-thread-1处理任务-4
pool-1-thread-2处理任务-5
pool-1-thread-1处理任务-8
pool-1-thread-2处理任务-9

线程池中的2个关闭方法

线程池提供了2个关闭方法：shutdown和shutdownNow，当调用者两个方法之后，线程池会遍历内部的工作线程，然后调用每个工作线程的interrrupt方法给线程发送中断信号，内部如果无法响应中断信号的可能永远无法终止，所以如果内部有无线循环的，最好在循环内部检测一下线程的中断信号，合理的退出。调用者两个方法中任意一个，线程池的isShutdown方法就会返回true，当所有的任务线程都关闭之后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。

调用shutdown方法之后，线程池将不再接口新任务，内部会将所有已提交的任务处理完毕，处理完毕之后，工作线程自动退出。

而调用shutdownNow方法后，线程池会将还未处理的（在队里等待处理的任务）任务移除，将正在处理中的处理完毕之后，工作线程自动退出。

至于调用哪个方法来关闭线程，应该由提交到线程池的任务特性决定，多数情况下调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

扩展线程池

虽然jdk提供了ThreadPoolExecutor这个高性能线程池，但是如果我们自己想在这个线程池上做一些扩展，比如，监控每个任务执行的开始时间，结束时间，或者一些其他自定义的功能，我们应该怎么办？

这个jdk已经帮我们想到了。ThreadPoolExecutor内部提供了几个方法beforeExecute、afterExecute、terminated，可以由开发人员自己去实现这些方法

public class ThreadPool6 implements Runnable {

    String name;

    ThreadPool6(String name) {
        this.name = name;
    }

    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 5, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1), Executors.defaultThreadFactory(), (r, executor1) -> {
            System.out.println("无法处理的任务 " + r.toString());
        }) {

            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println(System.currentTimeMillis() + "," + t.getName() + ",开始执行任务:" + r.toString());
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",任务:" + r.toString() + "，执行完毕!");
            }

            @Override
            protected void terminated() {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，关闭线程池!");
            }
        };

        for (int i = 0; i < 10; i++) {
            executor.execute(new ThreadPool6("任务-" + i));
        }
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdown();

    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "处理" + this.name);
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "runnable{" +
                "name='" + name + '\'' +
                '}';
    }
}

运行结果：

1608101120348,pool-1-thread-1,开始执行任务:runnable{name='任务-0'}
1608101120349,pool-1-thread-3,开始执行任务:runnable{name='任务-2'}
pool-1-thread-3处理任务-2
1608101120349,pool-1-thread-2,开始执行任务:runnable{name='任务-1'}
无法处理的任务 runnable{name='任务-6'}
1608101120349,pool-1-thread-4,开始执行任务:runnable{name='任务-4'}
pool-1-thread-4处理任务-4
pool-1-thread-1处理任务-0
1608101120349,pool-1-thread-5,开始执行任务:runnable{name='任务-5'}
pool-1-thread-5处理任务-5
无法处理的任务 runnable{name='任务-7'}
无法处理的任务 runnable{name='任务-8'}
pool-1-thread-2处理任务-1
无法处理的任务 runnable{name='任务-9'}
1608101122349,pool-1-thread-5,任务:runnable{name='任务-5'}，执行完毕!
1608101122349,pool-1-thread-3,任务:runnable{name='任务-2'}，执行完毕!
1608101122349,pool-1-thread-5,开始执行任务:runnable{name='任务-3'}
pool-1-thread-5处理任务-3
1608101122349,pool-1-thread-4,任务:runnable{name='任务-4'}，执行完毕!
1608101122349,pool-1-thread-1,任务:runnable{name='任务-0'}，执行完毕!
1608101122350,pool-1-thread-2,任务:runnable{name='任务-1'}，执行完毕!
1608101124350,pool-1-thread-5,任务:runnable{name='任务-3'}，执行完毕!
1608101124350,pool-1-thread-5，关闭线程池!

合理的配置线程池

要想合理的配置线程池，需要先分析任务的特性，可以从一下角度分析：

  • 任务的性质：cpu密集型任务，io密集型任务和混合型任务
  • 任务的优先级：高中低
  • 任务的执行时间：长中短
  • 任务的依赖性：是否依赖其他的系统资源，如数据库的链接

性质不同任务可以用不同规模的线程池分开处理。cpu密集型任务应该尽可能少的线程，如配置cpu数量+1个线程的线程池。由于io密集型任务并不是一直在执行任务，不能让cpu闲着，则应配置尽可能多的线程。如：cpu数量*2。混合型的任务，如果可以拆分，将其拆分成一个cpu密集型任务和一个io密集型任务，只要这两个任务执行的时间相差不是很大，那么分解后执行的吞吐量将高于串行执行的吞吐量。可以通过Runtime.getRuntime().availableProcessors()的方法获取cpu数量。优先级不同的任务，可以对线程池采用优先级队列来处理，让优先级高的先执行。

使用队列的时候建议使用有界队列，有界队列增加了系统的稳定，如果采用无界队列，任务太多的时候可能导致系统oom，直接让系统宕机。

线程池中线程数量的配置

线程池中总线程大小对系统的性能有一定的影响，我们的目标是希望系统能够发挥最好的性能，过多的或者过小的线程数无法有小的使用机器的性能。

Ncpu = CUP的数量
Ucpu = 目标CPU的使用率，0<=Ucpu<=1
W/C = 等待时间与计算时间的比例
为保存处理器达到期望的使用率，最有的线程池的大小等于：
Nthreads = Ncpu × Ucpu × (1+W/C)

一些使用建议

在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

那个少年~
关注
专栏目录
〖Python语法进阶篇⑦〗- 线程池与GIL全局锁
易编橙 · 终身成长社群，相遇已是上上签！
04-12 4万+
上一章节我们学习了线程的创建和常用方法，发现它的创建和使用与进程的创建、使用几乎是一样的，只是模块的使用有所区别而已。今天来学习一下线程池的创建与全局锁。线程池的创建于进程池的原理是相同的；关于GIL全局锁，暂时没有代码上的练习，而是对其概念进行一个简单的启蒙。接下来让我们进入正题，开始今天的学习。
jdk自带线程池实例详解
08-28
在最近做的一个项目中，需要大量的使用到多线程和线程池，下面就java自带的线程池和大家一起分享
Java并发（11）- 有关线程池的10个问题
weixin_34233856的博客
11-08 362
引言 在日常开发中，线程池是使用非常频繁的一种技术，无论是服务端多线程接收用户请求，还是客户端多线程处理数据，都会用到线程池技术，那么全面的了解线程池的使用、背后的实现原理以及合理的优化线程池的大小等都是非常有必要的。这篇文章会通过对十个常见问题的解答来讲解线程池的基本功能以及背后的原理，希望能对大家有所帮助。 举个例子来说明为什么要使用线程池，有什么好处？ jdk1.8中提供了哪几种基本的线程...
Java多线程11：线程池
weixin_30640769的博客
06-27 113
一、使用线程池和不使用线程池的差别 看一下使用线程池和不使用线程池时间上的差别。以下代码使用线程池 public class test { public static void main(String[] args) { long startTime = System.currentTimeMillis(); LinkedList<Int...
JDK 提供的线程池及使用场景
weixin_30408675的博客
06-30 128
JDK 为我们内置了四种常见线程池的实现，均可以使用Executors工厂类创建。 1.newFixedThreadPool public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, ...
线程池梳理
weixin_30416497的博客
01-24 132
线程池 目的 降低资源消耗 通过重复利用已创建的线程降低线程的创建和销毁的消耗 提高利用率 当任务到达时，可以省去线程的创建时间，直接去执行。 方便管理 线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性。使用线程池可以统一分配，调优和监控。 线程池的四种创建方式 newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要...
Java多线程并发-线程池-CompletableFuture
Juinjonn的博客
03-03 3043
线程的工作模式是，首先先要创建线程并指定线程需要执行的业务方法，然后再调用线程的 start() 方法，此时线程就从 NEW（新建）状态变成了 RUNNABLE（就绪）状态，此时线程会判断要执行的方法中有没有 synchronized 同步代码块，如果有并且其他线程也在使用此锁，那么线程就会变为 BLOCKED（阻塞等待）状态，当其他线程使用完此锁之后，线程会继续执行剩余的方法。
sm.rar_C 线程池
09-14
POSIX线程库提供了创建、管理线程的一系列接口，如`pthread_create()`用于创建线程，`pthread_join()`用于等待线程结束，以及`pthread_exit()`用于线程退出等。 线程池的工作流程通常包括以下几个步骤： 1. 初始化...
11. java线程池-ForkJoinPool
Java 程序源
09-01 1256
1. ForkJoinPool java7 提供了ForkJoinPool 来支持将一个任务采用递归方式分成多个小任务计算, 然后再把小任务的计算结果合并为总的结果. 1.1 ForkJoinPool 的创建方式 java7 提供了两个构造器: ForkJoinPool(int paralleism): 创建时指定并行线程数 ForkJoinPool(): 以当前机器的cpu个数(Runtim...
线程池1.0版(ThreadPool_fne.fne)-易语言
06-13
例如，线程池库可能包含了一系列的函数或方法，如创建线程池、提交任务、关闭线程池等，这些都可以通过易语言的语法进行调用。 在压缩包的文件列表中，有两个文件"static_lib"和"lib"。通常，"static_lib"可能是...
11 Java线程池详解
qq_38007019的博客
02-09 417
线程池使用及优势 线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在创建后启动这些任务，如果线程数据超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行 他的主要特点为：线程复用 控制最大并发数 管理线程 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁的消耗 第二：提高响应速度。当任务到达时任务可以不需要的等到线程创建就能立即执行。 第三：提高线程的可管理性。线程时稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使
11、ThreadPool线程池
AldrichEugene
09-09 245
一起学习juc
Thread Pool(线程池)技术
小白成长记录
06-15 3221
Thread Pool(线程池)技术技术背景介绍 在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内 存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象， 以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可 能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用 已有对象来服务就是一个需要解决的关键问题，其实这就是一些
C++11 ThreadPool--半同步半异步线程池
crkres9527
01-04 337
SyncQueue.h: 半同步半异步队列 #pragma once #include &lt;list&gt; #include &lt;mutex&gt; #include &lt;thread&gt; #include &lt;condition_variable&gt; #include &lt;iostream&gt; using namespace std; template...
JDK线程池源码分析
huangshanchun的专栏
11-16 1286
线程池，从字面的含义来看，是指管理一组工作线程（Worker Thread）的资源池。线程池是与工作队列（Work Queue）密切相关的，其中在工作队列中保存了需要执行的任务。工作线程的任务很简单：从任务队列中取出一个任务，执行任务，然后返回线程池并等待下一个任务。
主线程的子线程信息pool-1-thread-1
热门推荐
zwq1457的专栏
11-03 1万+
11-02 05:19:00.989 912 931 I am_anr : [0,31740,com.android.vending,952811205,Broadcast of Intent { act=android.intent.action.PACKAGE_REMOVED dat=package:com.android.vending flg=0x4000010 cmp=com.
多线程(1)------ThreadPoolExecutor底层原理
剑小纯的夜话白鹭
05-24 603
多线程(1)------线程池 前言 池化技术在我们的项目中是使用很频繁的,除了之前数据库的连接池,还有处理任务的线程池,在本文中将会来研究线程池的使用和原理. 正文 人类认识事物的方式有以下几步:是什么,能干什么,怎么用,原理. 所以本文将通过以上几步来逐步学习. 1. 线程池是什么? 在以前的单线程项目中,我们执行业务逻辑的流程是串行化的,一个main方法,然后依次调用其他的方法,这整个执...
JAVA11_22学习总结(线程池)
weixin_53118395的博客
11-22 152
11_22学习Java,线程池,后面就是io流了
上述代码多线程遍历192.168.0.2-192.168.0.255
最新发布
09-10
3. 创建一系列的任务实例，并将它们提交到线程池中执行。 示例代码可能如下所示： ```java import java.net.InetAddress; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值