类 Executors创建线程池用法

最新推荐文章于 2024-10-24 17:27:35 发布
最新推荐文章于 2024-10-24 17:27:35 发布
阅读量535 收藏
点赞数
分类专栏： java
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());
       for (int i = 0; i < 10; i++)
           daemonExec.execute(new MyThread(i));
       for (int i = 10; i < 20; i++)
           if (i == 10)
              maxPriorityExec.execute(new MyThread(i));
           else if (i == 11)
              minPriorityExec.execute(new MyThread(i));
           else
              defaultExec.execute(new MyThread(i));
    }
}
结果：
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)
Create Thread-5
Thread-5 run 1 time(s)
Thread-5 run 2 time(s)
Create Thread-6
Create Thread-7
Thread-7 run 1 time(s)
Thread-7 run 2 time(s)
Create Thread-8
Thread-8 run 1 time(s)
Thread-8 run 2 time(s)
Create Thread-9
Create Thread-10
Thread-10 run 1 time(s)
Thread-10 run 2 time(s)
Create Thread-11
Thread-9 run 1 time(s)
Thread-9 run 2 time(s)
Thread-6 run 1 time(s)
Thread-6 run 2 time(s)
Thread-3 run 1 time(s)
Thread-3 run 2 time(s)
Create Thread-12
Create Thread-13
Create Thread-14
Thread-12 run 1 time(s)
Thread-12 run 2 time(s)
Thread-13 run 1 time(s)
Thread-13 run 2 time(s)
Create Thread-15
Thread-15 run 1 time(s)
Thread-15 run 2 time(s)
Create Thread-16
Thread-16 run 1 time(s)
Thread-16 run 2 time(s)
Create Thread-17
Create Thread-18
Create Thread-19
Thread-14 run 1 time(s)
Thread-14 run 2 time(s)
Thread-17 run 1 time(s)
Thread-17 run 2 time(s)
Thread-18 run 1 time(s)
Thread-18 run 2 time(s)
Thread-19 run 1 time(s)
Thread-19 run 2 time(s)
Thread-11 run 1 time(s)
Thread-11 run 2 time(s)

本文出自 “子 孑” 博客，请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/70068

bestone0213
关注
专栏目录
Java面试题：为什么不建议使用Executors来创建线程池?建议使用 ThreadPoolExecutor 类直接创建和配置线程池？
iOS逆向与安全
11-15 221
缺乏对线程池的精细控制：Executors 提供的方法通常创建一些简单的线程池，如固定大小的线程池、单线程线程池等。不易处理异常：Executors 创建的线程池默认使用一种默认的异常处理策略，通常只会将异常打印到标准输出或记录到日志中，但不会提供更多的控制。可能导致不合理的线程数目：一些 Executors 方法创建的线程池默认将线程数目设置为非常大的值，这可能导致系统资源的浪费和性能下降。背景：线程池实现了对线程的复用，解决线程数量的不可控问题，解决线程的频繁创建和销毁带来的开销。
【异常】使用Executors创建线程池时SonarLint提示异常，Executors.newFixedThreadPool提示手动创建线程池，效果会更好哦。
本本本添哥
07-10 127
由于公司的代码检测平台检测到使用下面这种方式创建线程，从而提示“手动创建线程池，效果会更好哦”
Java ExecutorService管理线程池的简单用法
AKGWSB 's blog
03-27 384
可以在 java.util.concurrent中找到管理线程池的顶级接口 Executors import java.util.concurrent.*; Executors 接口定义了一个 execute()方法，接收一个实例化的Runnable对象，来启动这个任务，不过常用的还是 ExecutorService 类 ExecutorService 类继承自 Executors，但是提供相当...
Java:使用Executors创建和管理线程
jceator123的博客
07-27 151
Java:使用Executors创建和管理线程 1. 类 Executors 此类中提供的一些方法有： 1.1 public static ExecutorService newCachedThreadPool() 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。   ...
ExecutorService 建立一个多线程的线程池的步骤
weixin_34080571的博客
07-23 176
ExecutorService 建立一个多线程的线程池的步骤： 线程池的作用： 线程池功能是限制在系统中运行的线程数。      依据系统的环境情况，能够自己主动或手动设置线程数量。达到执行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其它线程排队等候。一个任务执行完成，再从队列的中取最前面的任务開始执行。若队列中没有等待进程。线程池的这一资...
线程管理框架Executor，ExecutorService
bit-cafe
02-09 1494
之前的我们的线程启动是使用new Thread().start()这种方式来启动的，而且当要执行多个任务的时候就会创建多个线程来执行这些任务，下面我们来看看使用Executor框架来管理线程。 为什么要使用Executor线程池框架 1、每次执行任务创建线程 new Thread()比较消耗性能，创建一个线程是比较耗时、耗资源的。 2、调用 new Thread()创建的线程缺乏管理，被称为
Executors多线程的简单使用
fzf474577969的专栏
01-13 335
package com.spidersite; import java.sql.Connection; import java.sql.DriverManager; import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import java.util.Hashtable; imp
为什么阿里巴巴要禁用Executors创建线程池？
JavaShark的博客
06-15 324
首先感谢大家在盖楼的间隙阅读本篇文章，通过阅读本篇文章你将了解到：如果只想知道原因可以直接拉到总结那管理一组工作线程。通过线程池复用线程有以下几点优点：根据返回的对象类型创建线程池可以分为三类：本文只讨论创建返回ThreadPoolExecutor对象在介绍Executors创建线程池方法前先介绍一下ThreadPoolExecutor，因为这些创建线程池的静态方法都是返回ThreadPoolExecutor对象，和我们手动创建ThreadPoolExecutor对象的区别就是我们不需要自己传构造函数的参数
SpringBoot学习之使用Executors创建线程池（四十二）
最新发布
易雪寒的博客
10-24 491
Executors.newCacheThreadPool()：可缓存线程池，先查看线程池中有没有之前创建的线程，如果有则直接使用。否则就新创建一个新的线程加入线程池中，我们经常用此类线程池来执行一些业务处理时间很短的任务。Executors.newFixedThreadPool()：创建一个固定（指定）长度可重用的线程池，可以控制最大创建数，超过最大长度之后就会放入到队列进行等待。
Java高并发编程实战14，强制禁止，线程池不允许使用Executors创建
学Java，找哪吒
10-16 1481
大家好，我是哪吒。在程序开发中，高并发场景越来越多，线程池首当其冲。简单回顾一下：《阿里巴巴 Java 开发手册》强制禁止，线程池不允许使用Executors创建，而是通过ThreadPoolExecutor的方式创建，这样的处理方式能让编写代码的工程师更加明确线程池的运行规则，避免资源耗尽的风险。Executors返回的线程池对象的弊端如下：好吧，昨天，我还通过创建了一个线程池，看来以后要注意了。具体分析以下【说明】中的内容，以FixedThreadPool为例，允许的请求队列长度为Integer.MAX
java多线程并发（二）——线程池Executors
WangShuo的专栏
04-17 1001
线程池的创建我们可以通过ThreadPoolExecutor来创建一个线程池。new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds,runnableTaskQueue, threadFactory,handler);创建一个线程池需要输入几个参数：corePoolSize（线程池的基本
Java多并发（七）| Executor框架（四种线程池详解）
光看不点赞的博客
06-25 1448
FixedThreadPool：SingleThreadExecutor：CachedThreadPool：ScheduledThreadPoolExecutor：SingleThreadScheduledExecutor： 概述 流程图 如果使用无界队列作为工作队列的影响，队列容量是MAX 2.2 SingleThreadExecutor详解 代码 概述 流程图 2.3 CachedThreadPool详解 代码 概述 流程图 Synchronou
多线程Executors类的入门介绍
qq_42219895的博客
03-06 132
首先，我这边使用的是jdk下面自带的Executors接口，可以通过package java.util.concurrent。该接口提供了一些创建线程池的方法，下面介绍几种常用的： //int nThreads表示创建固定数量线程的线程池 public static ExecutorService newFixedThreadPool(int nThreads)； //根据返回值可以看出 ...
java多线程并发包中的executors框架（线程池）和Fork/Join框架
weixin_38312502的博客
05-23 1753
1. 概述 1.1 Executor 是JDK1.5时引入的，引入该接口的主要目的是解耦任务本身和任务的执行。我们之前通过线程执行一个任务时，往往需要先创建一个线程，然后调用线程的start方法来执行任务。而Executor接口解耦了任务和任务的执行，该接口只有一个方法，入参为待执行的任务 public interface Executor { /** * 执行给定的Runnable任务. * 根据Executor的实现不同, 具体执行方式也不相同. void e
Java多线程 Executor并发框架
一只老风铃
02-18 1232
从JDK5开始提供Executor FrameWork  （java.util.concurrent） ——分离任务的创建和执行者的创建 ——线程可重复利用，降低new线程带来的消耗 共享线程池 ——创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率 ——预先创建好一定的Thread放于池中，当要使用时可直接向池中获取 ——线程并发数量过多，抢占系统资源从...
JAVA Executor实现并发线程
码农崛起
03-12 1150
通过Executor来管理线程，包括了启动线程和关闭线程等。通过java.util.concurrent.ExecutorService 对象来启动线程并执行任务，因为java.util.concurrent.ExecutorService的execute方法参数类型是Runnable类的实例。比采用Thread的start()来启动线程会比较好。 1.Executor简单的实现线程：
10个1s的任务放入coresize=1，maxsize=1，阻塞队列为容量1，拒绝策略为DiscardOld的线程池
littlewhitevg的博客
09-18 290
不多解释： public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1), new ThreadPoolExecut
Executors创建多线程demo
小蜜蜂咿嗡嗡的博客
04-01 510
了解java多线程，线程池的使用
【线程】Executor
lx0088的专栏
06-13 165
在生产环境中，为每一个任务分配一个线程，尤其是在大量创建线程的时候是由一定缺陷的：线程生命周期的开销非常高。线程的创建与销毁需要JVM和操作系统提供一些辅助操作，如果请求率非常高，那么为每个请求创建一个新线程将消耗大量的计算资源。资源消耗高。活跃的线程会消耗大量的内存资源。 稳定性差。线程过多可能抛出OutOfMemoryError异常。Executor 和 ExecutorsExecutor是提...
Java创建线程池的分类及案例
02-07
下面是使用 Executors 工厂类创建线程池的示例代码： ``` // 创建固定大小的线程池 Executor executor = Executors.newFixedThreadPool(5); // 创建只有一个线程的线程池 Executor executor = Executors....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值