精华内容
下载资源
问答
  • executors

    2020-03-13 14:07:21
    Java通过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:11
    import 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:16
    1. 类 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 的调用了,从而允许应用程序使用特殊的线程子类、属性等等。 
    此接口最简单的实现就是: 

    Java代码  收藏代码
    1. class SimpleThreadFactory implements ThreadFactory {  
    2.    public Thread newThread(Runnable r) {  
    3.      return new Thread(r);  
    4.    }  
    5.  }  

    3. 接口ExecutorService 
    该接口提供了管理终止的方法。 
    4.创建标准线程池启动线程 
    4.1 提供一个简单的实现Runnable接口的线程 
    MyThread.java 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors;  
    2.    
    3. public class MyThread implements Runnable {  
    4.     private int count = 1, number;  
    5.    
    6.     public MyThread(int num) {  
    7.        number = num;  
    8.        System.out.println("Create Thread-" + number);  
    9.     }  
    10.    
    11.     public void run() {  
    12.        while (true) {  
    13.            System.out.println("Thread-" + number + " run " + count+" time(s)");  
    14.            if (++count == 3)  
    15.               return;  
    16.        }  
    17.     }  
    18. }  

    这个线程会打印出相应的创建和执行信息。 

    4.2使用CachedThreadPool启动线程 
    CachedThreadPool.java 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors;  
    2. import java.util.concurrent.ExecutorService;  
    3. import java.util.concurrent.Executors;  
    4.    
    5. public class CachedThreadPool {  
    6.     public static void main(String[] args) {  
    7.        ExecutorService exec = Executors.newCachedThreadPool();  
    8.        for (int i = 0; i < 5; i++)  
    9.            exec.execute(new MyThread(i));  
    10.        exec.shutdown();  
    11.     }  
    12. }  

    结果: 
    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 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors;  
    2. import java.util.concurrent.ExecutorService;  
    3. import java.util.concurrent.Executors;  
    4.    
    5. public class FixedThreadPool {  
    6.     public static void main(String[] args) {  
    7.        ExecutorService exec = Executors.newFixedThreadPool(2);  
    8.        for (int i = 0; i < 5; i++)  
    9.            exec.execute(new MyThread(i));  
    10.        exec.shutdown();  
    11.     }  
    12. }  

    结果: 
    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 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors;  
    2. import java.util.concurrent.ExecutorService;  
    3. import java.util.concurrent.Executors;  
    4.    
    5. public class SingleThreadExecutor {  
    6.     public static void main(String[] args) {  
    7.        ExecutorService exec = Executors.newSingleThreadExecutor();  
    8.        for (int i = 0; i < 5; i++)  
    9.            exec.execute(new MyThread(i));  
    10.        exec.shutdown();  
    11.     }  
    12. }  

    结果: 
    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 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors.factory;  
    2. import java.util.concurrent.ThreadFactory;  
    3.    
    4. public class DaemonThreadFactory implements ThreadFactory {  
    5.     public Thread newThread(Runnable r) {  
    6.        Thread t = new Thread(r);  
    7.        t.setDaemon(true);  
    8.        return t;  
    9.     }  
    10. }  


    5.2 设置优先级属性 
    最高优先级MaxPriorityThreadFactory.java 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors.factory;  
    2. import java.util.concurrent.ThreadFactory;  
    3.    
    4. public class MaxPriorityThreadFactory implements ThreadFactory {  
    5.     public Thread newThread(Runnable r) {  
    6.        Thread t = new Thread(r);  
    7.        t.setPriority(Thread.MAX_PRIORITY);  
    8.        return t;  
    9.     }  
    10. }  

    最低优先级MinPriorityThreadFactory.java 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors.factory;  
    2. import java.util.concurrent.ThreadFactory;  
    3.    
    4. public class MinPriorityThreadFactory implements ThreadFactory {  
    5.     public Thread newThread(Runnable r) {  
    6.        Thread t = new Thread(r);  
    7.        t.setPriority(Thread.MIN_PRIORITY);  
    8.        return t;  
    9.     }  
    10. }  


    5.3启动带有属性设置的线程 
    ExecFromFactory.java 
    Java代码  收藏代码
    1. package com.zj.concurrency.executors;  
    2. import java.util.concurrent.ExecutorService;  
    3. import java.util.concurrent.Executors;  
    4. import com.zj.concurrency.executors.factory.DaemonThreadFactory;  
    5. import com.zj.concurrency.executors.factory.MaxPriorityThreadFactory;  
    6. import com.zj.concurrency.executors.factory.MinPriorityThreadFactory;  
    7.    
    8. public class ExecFromFactory {  
    9.     public static void main(String[] args) throws Exception {  
    10.        ExecutorService defaultExec = Executors.newCachedThreadPool();  
    11.        ExecutorService daemonExec = Executors  
    12.               .newCachedThreadPool(new DaemonThreadFactory());  
    13.        ExecutorService maxPriorityExec = Executors  
    14.               .newCachedThreadPool(new MaxPriorityThreadFactory());  
    15.        ExecutorService minPriorityExec = Executors  
    16.               .newCachedThreadPool(new MinPriorityThreadFactory());  
    展开全文
  • executors question

    2020-12-08 23:27:19
    EXECUTORS=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:32
    from 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:06
    Executors.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:27
    import java.util.concurrent.Executors; /* * 线程池的好处:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。 * * 如何实现线程的代码呢? * A:...
  • 关于Executors

    2018-08-01 11:36:45
    1.一般情况下,我们使用executors创建多线程时,就会使用默认的threadFactory(即调用只有一个参数的工厂方法),而创建出来的线程就是非守护的。而相应的程序就永远不会退出,如采用Executors创建定时调度任务时,...
  • 线程池 Executors

    2018-12-25 16:06:21
    import static java.util.concurrent.TimeUnit.NANOSECONDS; import java.util.concurrent.AbstractExecutorService; import java.util.concurrent....import java.util.concurrent.Executors; imp...
  • 各位志同道合的朋友们大家好,我是一个一直在一线互联网踩坑十余年的编码爱好者,...ThreadPoolExecutor 和 Executors,上一节学习了 ThreadPoolExecutor 的使用方式,本节重点来看 Executors 是如何创建线程池的...
  • Executors线程池

    2018-03-22 11:18:17
    Executors线程池种类: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:17
    id: 1602583277163 title: 四大线程池的使用 ...Executors提供了四个创建线程池的工厂方法,分别是: Executors.newSingleThreadExecutor() Executors.newFixedThreadPool() Executors.newCachedThreadPool() E.
  • Executors

    2017-12-06 21:03:09
    Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口,ExecutorService继承了Executor 创建固定数目线程的线程池。 public static ExecutorService newFixedThreadPool...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,795
精华内容 7,118
关键字:

executors