-
executors
2020-03-13 14:07:21Java通过Executors框架提供四种线程池 { /**创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。*/ ExecutorService executorService= Executors....Java通过Executors框架提供四种线程池
{ /**创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。*/ ExecutorService executorService= Executors.newCachedThreadPool(); for (int i=0;i<10;i++) { final int index=i; executorService.execute(new Runnable() { @Override public void run() { System.out.println(index); } }); } }
{ /**创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。**/ ExecutorService service= Executors.newFixedThreadPool(2); for (int i = 0; i <10 ; i++) { final int index=i; service.execute(new Runnable() { @Override public void run() { try { System.out.println(index); Thread.sleep(2000); }catch (Exception e ){ System.out.println(e.getMessage()); } } }); } }
{ public static void main(String[] args) { /**创建一个定长线程池,支持定时及周期性任务执行**/ testOne(); testTwo(); } public static void testOne(){ /**表示延迟3秒执行。*/ ScheduledExecutorService scheduledExecutorService= Executors.newScheduledThreadPool(2); scheduledExecutorService.schedule(new Runnable() { @Override public void run() { System.out.println("delay 2 seconds"); } },2, TimeUnit.SECONDS); } public static void testTwo(){ /**表示延迟1秒后每3秒执行一次*/ ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.scheduleAtFixedRate(new Runnable() { public void run() { System.out.println("delay 1 seconds, and excute every 3 seconds"); } }, 1, 3, TimeUnit.SECONDS); } }
{ /** 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行**/ ExecutorService executorService= Executors.newSingleThreadExecutor(); for (int i = 0; i <10 ; i++) { final int index = i; executorService.execute(new Runnable() { @Override public void run() { try { Thread.sleep(2000); System.out.println(index); }catch(Exception e){ e.getMessage(); } } }); } }
线程池里面做了些啥 ,JDK是有工具可以查看 jconsole 在JDK的bin目录下
程序在JDK中运行后的监控
技术原理都差不多 多做记录 多学习 -
Executors
2018-01-18 15:23:11import java.util.concurrent....import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * Executors 线程池学习import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; /** * Executors 线程池学习 * 线程池的思想还是一种对象池的思想、开辟一块内存空间来管理众多的未死亡的线程, * 池中的线程调度由线程池来管理。当线程有任务的时候从线程中取出一个进行任务,完成以后归还给对象池, * 这样可以避免反复的创建线程对象所带来的性能开销,节省资源。 */ public class Main { public static void main(String[] args) { //创建一个可重用固定线程数的线程池 //ExecutorService pools = Executors.newFixedThreadPool(5); //固定大小的任务线程池 //ExecutorService pools = Executors.newSingleThreadExecutor(); //单任务线程池 //ExecutorService pools = Executors.newCachedThreadPool(); //可变尺寸线程池 ScheduledExecutorService pools = Executors.newScheduledThreadPool(2);//延迟连接池 //创建线程 MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); MyThread t3 = new MyThread(); // MyThread t4 = new MyThread(); //MyThread t5 = new MyThread(); //将线程放入池中进行执行 pools.execute(t1); //pools.execute(t2); //pools.execute(t3); //pools.execute(t4); //pools.execute(t5); //使用延迟执行的方法风格 pools.schedule(t2,1000, TimeUnit.MILLISECONDS); pools.schedule(t3,10,TimeUnit.MILLISECONDS); //关闭线程池 pools.shutdown(); } }
-
Executors
2011-04-03 20:14:161. 类 Executors 此类中提供的一些方法有: 1.1 public static ExecutorService newCachedThreadPool() 创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务...1. 类 Executors
此类中提供的一些方法有:
1.1 public static ExecutorService newCachedThreadPool()
创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言,这些线程池通常可提高程序性能。
1.2 public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。
1.3 public static ExecutorService newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
这三个方法都可以配合接口ThreadFactory的实例一起使用。并且返回一个ExecutorService接口的实例。
2. 接口 ThreadFactory
根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了,从而允许应用程序使用特殊的线程子类、属性等等。
此接口最简单的实现就是:- class SimpleThreadFactory implements ThreadFactory {
- public Thread newThread(Runnable r) {
- return new Thread(r);
- }
- }
3. 接口ExecutorService
该接口提供了管理终止的方法。
4.创建标准线程池启动线程
4.1 提供一个简单的实现Runnable接口的线程
MyThread.java- package com.zj.concurrency.executors;
- public class MyThread implements Runnable {
- private int count = 1, number;
- public MyThread(int num) {
- number = num;
- System.out.println("Create Thread-" + number);
- }
- public void run() {
- while (true) {
- System.out.println("Thread-" + number + " run " + count+" time(s)");
- if (++count == 3)
- return;
- }
- }
- }
这个线程会打印出相应的创建和执行信息。
4.2使用CachedThreadPool启动线程
CachedThreadPool.java- package com.zj.concurrency.executors;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- public class CachedThreadPool {
- public static void main(String[] args) {
- ExecutorService exec = Executors.newCachedThreadPool();
- for (int i = 0; i < 5; i++)
- exec.execute(new MyThread(i));
- exec.shutdown();
- }
- }
结果:
Create Thread-0
Create Thread-1
Create Thread-2
Create Thread-3
Thread-0 run 1 time(s)
Thread-0 run 2 time(s)
Thread-1 run 1 time(s)
Thread-1 run 2 time(s)
Thread-2 run 1 time(s)
Thread-2 run 2 time(s)
Create Thread-4
Thread-4 run 1 time(s)
Thread-4 run 2 time(s)
Thread-3 run 1 time(s)
Thread-3 run 2 time(s)
4.3 使用FixedThreadPool启动线程
FixedThreadPool.java- package com.zj.concurrency.executors;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- public class FixedThreadPool {
- public static void main(String[] args) {
- ExecutorService exec = Executors.newFixedThreadPool(2);
- for (int i = 0; i < 5; i++)
- exec.execute(new MyThread(i));
- exec.shutdown();
- }
- }
结果:
Create Thread-0
Create Thread-1
Create Thread-2
Create Thread-3
Create Thread-4
Thread-0 run 1 time(s)
Thread-0 run 2 time(s)
Thread-2 run 1 time(s)
Thread-2 run 2 time(s)
Thread-3 run 1 time(s)
Thread-3 run 2 time(s)
Thread-4 run 1 time(s)
Thread-4 run 2 time(s)
Thread-1 run 1 time(s)
Thread-1 run 2 time(s)
4.4 使用SingleThreadExecutor启动线程
SingleThreadExecutor.java- package com.zj.concurrency.executors;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- public class SingleThreadExecutor {
- public static void main(String[] args) {
- ExecutorService exec = Executors.newSingleThreadExecutor();
- for (int i = 0; i < 5; i++)
- exec.execute(new MyThread(i));
- exec.shutdown();
- }
- }
结果:
Create Thread-0
Create Thread-1
Create Thread-2
Create Thread-3
Create Thread-4
Thread-0 run 1 time(s)
Thread-0 run 2 time(s)
Thread-1 run 1 time(s)
Thread-1 run 2 time(s)
Thread-2 run 1 time(s)
Thread-2 run 2 time(s)
Thread-3 run 1 time(s)
Thread-3 run 2 time(s)
Thread-4 run 1 time(s)
Thread-4 run 2 time(s)
5.配合ThreadFactory接口的使用
我们试图给线程加入daemon和priority的属性设置。
5.1设置后台线程属性
DaemonThreadFactory.java- package com.zj.concurrency.executors.factory;
- import java.util.concurrent.ThreadFactory;
- public class DaemonThreadFactory implements ThreadFactory {
- public Thread newThread(Runnable r) {
- Thread t = new Thread(r);
- t.setDaemon(true);
- return t;
- }
- }
5.2 设置优先级属性
最高优先级MaxPriorityThreadFactory.java- package com.zj.concurrency.executors.factory;
- import java.util.concurrent.ThreadFactory;
- public class MaxPriorityThreadFactory implements ThreadFactory {
- public Thread newThread(Runnable r) {
- Thread t = new Thread(r);
- t.setPriority(Thread.MAX_PRIORITY);
- return t;
- }
- }
最低优先级MinPriorityThreadFactory.java- package com.zj.concurrency.executors.factory;
- import java.util.concurrent.ThreadFactory;
- public class MinPriorityThreadFactory implements ThreadFactory {
- public Thread newThread(Runnable r) {
- Thread t = new Thread(r);
- t.setPriority(Thread.MIN_PRIORITY);
- return t;
- }
- }
5.3启动带有属性设置的线程
ExecFromFactory.java- package com.zj.concurrency.executors;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- import com.zj.concurrency.executors.factory.DaemonThreadFactory;
- import com.zj.concurrency.executors.factory.MaxPriorityThreadFactory;
- import com.zj.concurrency.executors.factory.MinPriorityThreadFactory;
- public class ExecFromFactory {
- public static void main(String[] args) throws Exception {
- ExecutorService defaultExec = Executors.newCachedThreadPool();
- ExecutorService daemonExec = Executors
- .newCachedThreadPool(new DaemonThreadFactory());
- ExecutorService maxPriorityExec = Executors
- .newCachedThreadPool(new MaxPriorityThreadFactory());
- ExecutorService minPriorityExec = Executors
- .newCachedThreadPool(new MinPriorityThreadFactory());
-
executors question
2020-12-08 23:27:19EXECUTORS=2 </code></pre> <pre><code> nodes/emerge.conf EXECUTORS=1 TAGS=emerge </code></pre> <p>but laminar spins up 3 jobs for a job tagged emerge using jobs/job.conf <p>Am I using it ... -
apscheduler executors
2020-08-15 09:59:32from apscheduler.executors.pool import ThreadPoolExecutor executors = { 'default': ThreadPoolExecutor(20) #最多20个线程同时执行 } scheduler = BackgroundScheduler(executors=executors) 2.以进程方式...配置:以进程或线程方式执行任务
1.以线程执行任务
from apscheduler.executors.pool import ThreadPoolExecutor executors = { 'default': ThreadPoolExecutor(20) #最多20个线程同时执行 } scheduler = BackgroundScheduler(executors=executors)
2.以进程方式执行任务
from apscheduler.executors.pool import ProcessPoolExecutor executors = { 'default': ProcessPoolExecutor(3) #最多3个进程同时执行 } scheduler = BackgroundScheduler(executors=executors)
-
Refactor executors
2020-11-30 11:22:11<div><ul>[x] Directly pass all read jobs to the executor (which still by default handles them one by one).</li><li>[x] Move executors into a full module that allows for submodules.</li></ul>该提问来源... -
Executors弊端
2019-12-13 14:08:06Executors.newFixedThreadPool(1); // LinkedBlockingQueue 无界的队列 可能会导致内存溢出 Executors.newCachedThreadPool(); // maximumPoolSize 使用了最大值,可能会导致内存溢出 ... -
Executors框架
2020-04-25 23:46:53文章目录Executors框架CompletionServiceCompletableFuture Executors框架 CompletionService 提供了异步任务的执行与结果的封装,轻松实现多线程任务,并方便的集中处理上述任务的结果(且任务最先完成的先返回) ... -
Executors介绍
2018-09-09 08:53:00《阿里巴巴java开发手册》线程池不使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样 的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 主要原因是使用Executors创建线程池不会... -
Executors使用
2018-11-14 09:18:50最近学习了BlockingQueue,在学习过程中看到了Executors的使用,以前没有专门的去了解和查看源码,现在去学习一下 Java通过Executors提供四种线程池,分别为: newCachedThreadPool 创建一个可缓存线程池,如果... -
线程池Executors
2019-10-09 09:16:27import java.util.concurrent.Executors; /* * 线程池的好处:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。 * * 如何实现线程的代码呢? * A:... -
关于Executors
2018-08-01 11:36:451.一般情况下,我们使用executors创建多线程时,就会使用默认的threadFactory(即调用只有一个参数的工厂方法),而创建出来的线程就是非守护的。而相应的程序就永远不会退出,如采用Executors创建定时调度任务时,... -
线程池 Executors
2018-12-25 16:06:21import static java.util.concurrent.TimeUnit.NANOSECONDS; import java.util.concurrent.AbstractExecutorService; import java.util.concurrent....import java.util.concurrent.Executors; imp... -
java executors 详解_线程池—Executors 详解
2021-03-05 11:09:15各位志同道合的朋友们大家好,我是一个一直在一线互联网踩坑十余年的编码爱好者,...ThreadPoolExecutor 和 Executors,上一节学习了 ThreadPoolExecutor 的使用方式,本节重点来看 Executors 是如何创建线程池的... -
Executors线程池
2018-03-22 11:18:17Executors线程池种类:1、newCachedThreadPool(缓存线程池) 2、newFixedThreadPool(定长线程池) 3、newScheduledThreadPool(调度线程池) ... -
Remove instance executors
2020-11-30 02:16:55<div><p>The idea is that executors are easy to provide at the application level, if needed, and that the ones provided by Apollo are very rarely used in practice. So it's a feature of Apollo that ... -
Executors四大线程池工厂方法的使用
2020-10-15 15:19:17id: 1602583277163 title: 四大线程池的使用 ...Executors提供了四个创建线程池的工厂方法,分别是: Executors.newSingleThreadExecutor() Executors.newFixedThreadPool() Executors.newCachedThreadPool() E. -
Executors类
2017-12-06 21:03:09Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口,ExecutorService继承了Executor 创建固定数目线程的线程池。 public static ExecutorService newFixedThreadPool...
收藏数
17,795
精华内容
7,118