使用Executors创建和管理线程

最新推荐文章于 2023-07-08 16:38:48 发布
最新推荐文章于 2023-07-08 16:38:48 发布
阅读量253 收藏
点赞数
分类专栏： javaSE
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)

本文出自 “i张俊” 博客，出处http://zhangjunhd.blog.51cto.com/113473/70068

Chenny丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程中使用Executors类创建和管理线程的用法
09-02
主要介绍了Java并发编程中使用Executors类创建和管理线程的用法,文中举了用其启动线程和设置线程优先级的例子,需要的朋友可以参考下
Executors创建多线程demo
小蜜蜂咿嗡嗡的博客
04-01 484
了解java多线程，线程池的使用
关于Executors创建和管理线程的那些事
09-28 272
线程是并发最基本的单元。Java线程本质上被映射到操作系统线程，并且每个线程对象对应着一个计算机底层线程。 来张图说明一下： 1．自己管理线程并不是很好的选择，最大劣势是，你很容易过分的关注线程的数量。线程是很昂贵的对象，创建它们需要耗费大量的内存和时间。线程太少，你不能获得良好的并发性；线程太多，将很可能导致内存问题，调度也变得更复杂。 2．幸运的是，JVM为我们提供了线程管理的功
Java:使用Executors创建和管理线程
jceator123的博客
07-27 130
Java:使用Executors创建和管理线程 1. 类 Executors 此类中提供的一些方法有： 1.1 public static ExecutorService newCachedThreadPool() 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。   ...
Java ExecutorService管理线程池的简单用法
AKGWSB 's blog
03-27 339
可以在 java.util.concurrent中找到管理线程池的顶级接口 Executors import java.util.concurrent.*; Executors 接口定义了一个 execute()方法，接收一个实例化的Runnable对象，来启动这个任务，不过常用的还是 ExecutorService 类 ExecutorService 类继承自 Executors，但是提供相当...
创建线程的第四种方法：Executors线程池
weixin_40215624的博客
05-31 204
代码示例： private static void ExecutorMethod() { //ExecutorService service = Executors.newSingleThreadExecutor(); //一池一线程 ExecutorService service = Executors.newFixedThreadPool(3); //一池三线程 //Executor...
Java并发编程中使用Executors类创建和管理线程的
10-30
Java并发编程中使用Executors类创建和管理线程的用法共4页.pdf.zip
Java线程并发控制基础知识
12-22
　推荐用ThreadPoolExecutor的工厂构造类Executors来管理线程池，线程复用线程池开销较每次申请新线程小，具体看代码以及注释   public class TestThread { /** * 使用线程池的方式是复用...
google用于管理线程，符合阿里线程池规范ThreadFactoryBuilder的jar包 guava 27.0.1-jre.jar
01-11
最近阿里发布的 Java开发手册中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 其中ThreadFactoryBuilder...
第7章-JUC多线程v1.1.pdf
02-21
本质上是一个对象池, 用来管理线程资源. 在任务执行前, 需要从线程池中拿出线程来执行. 在任务执行完成之后, 需要把线程放回线程池. 线程池好处: 降低资源的消耗, 线程本身是一种资源, 创建和销毁都会消耗CPU...
Executor内部如何创建线程？
Benson的专栏
02-18 2409
对于Thread，它既是工作单元(含有run方法)，也是执行机制(start方法)。而executor framework将两者解耦，实现了工作单元和执行机制的分离。executor负责执行任务,runnable和callable代表业务逻辑单元（前者无返回值，后者有返回值)。使用executor framework，我们无须再手动创建Thread，因为executor framework有一个专
线程的基础
qq_24256955的博客
08-04 284
一．进城、线程、协程之间的联系。 进程就可以看做是一个应用程序，而线程是进程的执行单元，多个线程组成一个完整的进程，而协程的话就是线程的拆分，它将线程细分化，能进一步优化并发编程，暂不做细讲。 二．线程的生命周期： ①新生态：Thread t=new Thread（）； ②就绪：t.start();线程被启动，等待被分配给CPU的时间片，获取CPU资源 ③运行：线程获取CPU资源执行ru
【线程】Executor
lx0088的专栏
06-13 138
在生产环境中，为每一个任务分配一个线程，尤其是在大量创建线程的时候是由一定缺陷的：线程生命周期的开销非常高。线程的创建与销毁需要JVM和操作系统提供一些辅助操作，如果请求率非常高，那么为每个请求创建一个新线程将消耗大量的计算资源。资源消耗高。活跃的线程会消耗大量的内存资源。 稳定性差。线程过多可能抛出OutOfMemoryError异常。Executor 和 ExecutorsExecutor是提...
Java并发多线程编程——Executors类
小志的博客
06-16 1367
一、Executors的理解 Executors类属于java.util.concurrent包； 线程池的创建分为两种方式：ThreadPoolExecutor 和 Executors； Executors（静态Executor工厂）用于创建线程池； 工厂和工具方法Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory和Callable在此包中定义的类； jdk1.8API中的解释如下: 二、Executors常用的
多线程Executor
最新发布
weixin_44315786的博客
07-08 1025
多线程创建，队列，策略
Java高并发编程中Executor、ExecutorService的使用及详细介绍-刘宇
刘宇的博客
08-12 2381
作者：刘宇。一、什么是Executor框架二、Executor框架示意图三、ExecutorService的方法详解1、submit方法2、invokeAny方法3、invokeAll方法4、awaitTermination方法5、isShutdown方法6、shutdown方法7、shutdownNow方法8、isTerminated方法四、ExecutorService练习1、如何捕获线程执行过程中出现的异常并处理1.1 利用Thread中uncaughtExceptionHandler来处理
Java多线程 Executor并发框架
一只老风铃
02-18 1202
从JDK5开始提供Executor FrameWork  （java.util.concurrent） ——分离任务的创建和执行者的创建 ——线程可重复利用，降低new线程带来的消耗 共享线程池 ——创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率 ——预先创建好一定的Thread放于池中，当要使用时可直接向池中获取 ——线程并发数量过多，抢占系统资源从...
线程池实现高并发访问数据库
weixin_43292600的博客
09-24 296
JAVA线程池实现并发访问数据库wait()和notify()阻塞唤醒机制代码实现 wait()和notify()阻塞唤醒机制 使用wait()阻塞线程，释放掉同步代码块的锁。调用notifyAll()唤醒所有被阻塞的线程，高并发访问数据库中同一张表，同一条数据。 代码实现 controller层的逻辑 package com.h5eco.wolf.aa.cmds; import java.util.concurrent.ExecutorService; import java.util.concurre
java多线程 excutor,java多线程并发executorservice(任务调度)类
weixin_29775951的博客
03-15 108
package com.yao;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.ScheduledFuture;import java.util.concurrent.TimeUnit;/*** 以下是一个带方...
一般new ThreadPoolExecutor还是使用Executors来进行创建
05-29
在 Java 中，创建线程池有两种方式：一种是通过 ThreadPoolExecutor 类手动创建线程池，另一种是通过 Executors 工具类来创建线程池。 如果需要对线程池进行更加灵活的配置和管理，建议使用 ThreadPoolExecutor 类手动创建线程池。通过手动创建线程池，可以自定义线程池中线程的数量、任务队列的大小、线程的存活时间、拒绝策略等参数，从而更好地满足不同的需求。 而如果只是需要创建一个简单的线程池，可以使用 Executors 工具类来创建。Executors 提供了一些静态方法，可以快速创建不同类型的线程池，如 newCachedThreadPool()、newFixedThreadPool()、newSingleThreadExecutor() 等。这些方法提供了一些默认的参数配置，简化了线程池的创建过程。 需要注意的是，虽然通过 Executors 工具类创建线程池更加简单，但是这种方式可能导致一些问题，比如无限制的任务队列大小、线程池大小不可控等。因此，在实际开发中，建议根据具体场景选择合适的方式来创建线程池。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值