Java:使用Executors创建和管理线程

最新推荐文章于 2024-07-09 12:24:49 发布
最新推荐文章于 2024-07-09 12:24:49 发布
阅读量105 收藏
点赞数
分类专栏： java编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanapple123/article/details/83982688
版权
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

lanapple123
关注
专栏目录
Java多线程（四）：使用Executors创建线程池及其注意事项
qq_28834355的博客
11-07 533
文章目录1. 简介2. newCachedThreadPool3. newFiexedThreadPool4. newSingleThreadExecutor5. newScheduledThreadPool6. 注意事项（必看） 1. 简介 Executors 也是创建线程池的工具，通过Executors 可以简单地创建线程池对象。主要包括以下4种创建方式： newCachedThreadPool：创建一个可缓存的线程池。每个创建的线程默认偶60秒空闲时间，前面创建的线程只要还没被回收，并且处于空闲状
Executors类创建四种常见线程池，Tencent后台开发Java岗二面
m0_61364397的博客
10-27 230
pool-1-thread-1 is running… pool-1-thread-1 is running… pool-1-thread-1 is running… 底层实现 /** 核心线程池大小=1 最大线程池大小为1 线程过期时间为0ms LinkedBlockingQueue作为工作队列 */ public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExec
使用Executors创建线程
豢龙先生
02-12 478
可以使用 -Xss 指定创建每个线程需要的空间，默认是1024KB。newSingleThreadExecutor： 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
《Java线程池》Executor 以及Executors
wojiushimogui的博客
08-05 1363
《Java线程池》Executor 以及Executors线程池的相关类的体系结构如下：先看Executor接口，是最根上的接口 public interface Executor { /* * Executes the given command at some time in the future. The command * may
Java并发编程中使用Executors类创建和管理线程的用法
09-02
Java并发编程中，`java.util.concurrent.Executors` 类是一个至关重要的工具类，它提供了一系列静态方法，用于创建和管理线程池以及相关的线程执行服务。`Executors` 类简化了线程池的创建和线程的调度，使得开发者...
Java并发编程中使用Executors类创建和管理线程的
10-30
Java提供了一套强大的并发工具，其中`java.util.concurrent.Executors`类是核心部分，它允许我们创建和管理线程池，极大地简化了并发编程。本篇将深入探讨`Executors`类的使用方法及其背后的并发原理。 `Executors`...
掌握Java Executors类：创建与管理线程的实战教程
在Java并发编程中，`Executors`类扮演着至关重要的角色，它为我们提供了方便的方式来创建和管理线程，优化多线程处理。`Executors`类是Java并发编程的核心工具之一，它封装了多个工厂方法，用于创建不同类型的线程池...
Executors创建线程池
日拱一卒
10-22 205
总结 Executors创建线程池 Java中创建线程池很简单，只需要调用Executors中相应的便捷方法即可，比如Executors.newFixedThreadPool(int nThreads)，但是便捷不仅隐藏了复杂性，也为我们埋下了潜在的隐患（OOM，线程耗尽）。 Executors创建线程池便捷方法列表： 方法名 功能 newFixedThreadPool(int nT...
Executors创建线程池（三）
pengdayong77的博客
03-28 196
Executors创建线程池执行短且多的任务操作。实际使用时，需要考虑1.创建一个线程固定的线程池长期存在，程序中使用时间短的操作可以直接给到线程池中去执行。2.需要考虑程序异常停止后，线程池中未执行的操作如何补救执行。 Executors.newFixedThreadPool 创建固定大小的线程池。这个是常用的类型。 Executors.newCachedThreadPool 无边界的线程池...
关于Executors创建和管理线程的那些事
09-28 303
线程是并发最基本的单元。Java线程本质上被映射到操作系统线程，并且每个线程对象对应着一个计算机底层线程。 来张图说明一下： 1．自己管理线程并不是很好的选择，最大劣势是，你很容易过分的关注线程的数量。线程是很昂贵的对象，创建它们需要耗费大量的内存和时间。线程太少，你不能获得良好的并发性；线程太多，将很可能导致内存问题，调度也变得更复杂。 2．幸运的是，JVM为我们提供了线程管理的功
Java面试题：为什么不建议使用Executors来创建线程池?建议使用 ThreadPoolExecutor 类直接创建和配置线程池？
iOS逆向与安全
11-15 221
缺乏对线程池的精细控制：Executors 提供的方法通常创建一些简单的线程池，如固定大小的线程池、单线程线程池等。不易处理异常：Executors 创建的线程池默认使用一种默认的异常处理策略，通常只会将异常打印到标准输出或记录到日志中，但不会提供更多的控制。可能导致不合理的线程数目：一些 Executors 方法创建的线程池默认将线程数目设置为非常大的值，这可能导致系统资源的浪费和性能下降。背景：线程池实现了对线程的复用，解决线程数量的不可控问题，解决线程的频繁创建和销毁带来的开销。
Executors-四种创建线程的手段
一个搬砖工人
11-26 1599
从构造方法可以看出，它创建了一个固定大小的线程池，每次提交一个任务就创建一个线程，直到线程数达到线程池的最大值nThreads。在提交第4个任务时，因为线程池的大小已经达到了3并且前3个任务在运行中，所以第4个任务被放入了队列，等待有空闲的线程时再被运行。这里的单线程执行指的是线程池内部，从线程池外的角度看，主线程在提交任务到线程池时并没有阻塞，仍然是异步的。因为这种线程有新的任务提交，就会创建新的线程（线程池中没有空闲线程时），不需要等待，所以提交的5个任务的运行时间是一样的。
Java Executors类的9种创建线程池的方法及应用场景分析
最新发布
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
07-09 810
在Java中，Executors 类提供了多种静态工厂方法来创建不同类型的线程池。在学习线程池的过程中，一定避不开Executors类，掌握这个类的使用、原理、使用场景，对于实际项目开发时，运用自如，以下是一些常用的方法，V哥来一一细说：: 创建一个可缓存的线程池，如果线程池中的线程超过60秒没有被使用，它们将被终止并从缓存中移除。: 创建一个固定大小的线程池，其中 nThreads 指定了线程池中线程的数量。: 创建一个单线程的执行器，它创建单个工作线程来执行任务。: 创建一个固定大小的线程池，它可以根据
6.Java并发编程—深入剖析Java Executors：探索创建线程的5种神奇方式
q1372302825的博客
03-13 458
本文深入剖析了Java中使用Executors类创建线程的5种方式。这些方式包括newSingleThreadExecutor()、newFixedThreadPool(int nThreads)、newCachedThreadPool()、newScheduledThreadPool(int corePoolSize)和newWorkStealingPool(int parallelism)。每种方式都具有独特的特点和适用场景。通过了解这些线程池的工作原理和适用性，我们可以根据实际需求选择最合适的线程池类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值