Java多线程并发编程，多线程优化-线程池的常用创建方式及使用总结

最新推荐文章于 2022-07-07 09:59:22 发布
最新推荐文章于 2022-07-07 09:59:22 发布
阅读量586 收藏 1
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyliyongblue/article/details/105249050
版权

1、简单的线程池创建Executors

1.1 newCachedThreadPool()

public static ExecutorService newCachedThreadPool()

说明：创建一个线程池。需要使用线程时从线程池中获取线程，如果无可用线程，则创建一个线程，在使用使用后放入线程池。线程池中60秒未使用的线程将被终止并从缓存中移除。

因此通过该方法创建的线程池，长时间不适用，将不怎么消耗资源。

该线程池适合用于执行短暂异步任务

代码示例：

package com.liyong.reactor.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleNewCachedThreadPool {
	
	static class Worker implements Runnable {
		@Override
		public void run() {
			try {
				Thread.sleep(30);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " exe success");
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		ExecutorService executor = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			Thread.sleep(10);
			executor.submit(new Worker());
		}
		executor.shutdown();
	}
}

 运行结果：

pool-1-thread-1 exe success
pool-1-thread-2 exe success
pool-1-thread-3 exe success
pool-1-thread-4 exe success
pool-1-thread-1 exe success
pool-1-thread-2 exe success
pool-1-thread-3 exe success
pool-1-thread-4 exe success
pool-1-thread-1 exe success
pool-1-thread-2 exe success

说明：每个任务执行30ms，每10ms提交一个任务，所以部分线程得已复用。

1.2 newFixedThreadPool(int nThreads)

public static ExecutorService newFixedThreadPool(int nThreads)

 说明：该方法创建一个固定线程数量、无界等待队列的线程池，在任何时候最多只有nThread个线程在处理任务。当所有线程都被占用时，任务将放到等待队列中，等待队列无限大。池中的线程永久有效，直到明确的关闭线程池为止。

该线程池可用于可控的任务提交和任务执行，否则在大量任务堆积时，会造成OOM，而且已经提交的任务就丢失了。

代码实例：

package com.liyong.reactor.thread;

import java.time.LocalTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleNewFixedThreadPool {
	static class Worker implements Runnable {

		private final int index;

		public Worker(int index) {
			this.index = index;
		}

		@Override
		public void run() {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(LocalTime.now() + " index:" + index + "  " + Thread.currentThread().getName() + " exe success");
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ExecutorService executor = Executors.newFixedThreadPool(4);
		for (int i = 0; i < 10; i++) {
			Thread.sleep(10);
			System.out.println(LocalTime.now() + " thread index: " + (i + 1) + " submit success");
			executor.submit(new Worker(i + 1));
		}
		executor.shutdown();
	}
}

 运行结果：

16:54:58.823 thread index: 1 submit success
16:54:58.835 thread index: 2 submit success
16:54:58.845 thread index: 3 submit success
16:54:58.855 thread index: 4 submit success
16:54:58.865 thread index: 5 submit success
16:54:58.875 thread index: 6 submit success
16:54:58.885 thread index: 7 submit success
16:54:58.895 thread index: 8 submit success
16:54:58.905 thread index: 9 submit success
16:54:58.915 thread index: 10 submit success
16:54:59.125 index:1  pool-1-thread-1 exe success
16:54:59.135 index:2  pool-1-thread-2 exe success
16:54:59.145 index:3  pool-1-thread-3 exe success
16:54:59.155 index:4  pool-1-thread-4 exe success
16:54:59.425 index:5  pool-1-thread-1 exe success
16:54:59.435 index:6  pool-1-thread-2 exe success
16:54:59.445 index:7  pool-1-thread-3 exe success
16:54:59.455 index:8  pool-1-thread-4 exe success
16:54:59.725 index:9  pool-1-thread-1 exe success
16:54:59.735 index:10  pool-1-thread-2 exe success

说明：设置了固定的线程池大小为4，每个线程执行300ms，每隔10ms提交一个任务到线程池中。

从输出结果 ，可以看到有且仅有4个线程能执行任务，剩下的任务都在进行排队。比如 index为10的任务，16:54:58.915提交任务，16:54:59.735完成任务，总共耗时820ms，执行时间为300ms，在队列中等待了520ms的时间。

1.3 newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()

说明：创建一个单线程，无界队列的线程池。任务保证顺序执行，随时都有且仅有一个线程在执行任务。

适合场景：适合可控任务数量，可控执行时间的任务使用，并且提供了任务的顺序执行。

代码示例：

package com.liyong.reactor.thread;

import java.time.LocalTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleNewSingleThreadPool {
	static class Worker implements Runnable {

		private final int index;

		public Worker(int index) {
			this.index = index;
		}

		@Override
		public void run() {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(LocalTime.now() + " index:" + index + "  " + Thread.currentThread().getName() + " exe success");
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ExecutorService executor = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 5; i++) {
			Thread.sleep(10);
			System.out.println(LocalTime.now() + " thread index: " + (i + 1) + " submit success");
			executor.submit(new Worker(i + 1));
		}
		executor.shutdown();
	}
}

 执行结果：

17:05:52.656 thread index: 1 submit success
17:05:52.667 thread index: 2 submit success
17:05:52.677 thread index: 3 submit success
17:05:52.687 thread index: 4 submit success
17:05:52.697 thread index: 5 submit success
17:05:52.757 index:1  pool-1-thread-1 exe success
17:05:52.857 index:2  pool-1-thread-1 exe success
17:05:52.957 index:3  pool-1-thread-1 exe success
17:05:53.057 index:4  pool-1-thread-1 exe success
17:05:53.157 index:5  pool-1-thread-1 exe success

说明： 任务执行耗时100ms，没10ms提交一个任务，总共提交5个任务，由结果的index序号观察，任务是顺序执行的，并且仅有一个线程在处理任务，其他未处理的任务再排队等待。index=5的任务，从提交任务到处理完成，总耗时460ms，等待了360ms的时间

1.4、newScheduledThreadPool(int corePoolSize)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

 说明：创建一个线程池，可以指定线程数，排队队列无界，可以调度命令在给定的延迟之后运行，或定期执行。

代码示例：

package com.liyong.reactor.thread;

import java.io.IOException;
import java.time.LocalTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SimpleNewScheduledThreadPool {
	static class Worker implements Runnable {

		private final int index;

		public Worker(int index) {
			this.index = index;
		}

		@Override
		public void run() {
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(LocalTime.now() + " index:" + index + "  " + Thread.currentThread().getName() + " exe success");
		}
	}

	public static void main(String[] args) throws InterruptedException, IOException {
		ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);
		
		System.out.println(LocalTime.now() + " thread index: " + 1111 + " submit success");
		executor.schedule(new Worker(1111), 5, TimeUnit.SECONDS);
		
		System.out.println(LocalTime.now() + " thread index: " + 2222 + " submit success");
		executor.scheduleWithFixedDelay(new Worker(2222), 6000, 200, TimeUnit.MILLISECONDS);
		
//		System.out.println(LocalTime.now() + " thread index: " + 3333 + " submit success");
//		executor.scheduleAtFixedRate(new Worker(3333), 6000, 200, TimeUnit.MILLISECONDS);
		
		System.in.read();
		executor.shutdown();
	}
}

 输出结果：

17:37:23.877 thread index: 1111 submit success
17:37:23.878 thread index: 2222 submit success
17:37:29.179 index:1111  pool-1-thread-1 exe success
17:37:30.179 index:2222  pool-1-thread-2 exe success
17:37:30.680 index:2222  pool-1-thread-1 exe success
17:37:31.181 index:2222  pool-1-thread-2 exe success
17:37:31.682 index:2222  pool-1-thread-3 exe success
17:37:32.183 index:2222  pool-1-thread-1 exe success
17:37:32.684 index:2222  pool-1-thread-4 exe success
17:37:33.185 index:2222  pool-1-thread-2 exe success
17:37:33.686 index:2222  pool-1-thread-2 exe success

说明： 任务执行300ms，index 1111的任务5s后开始执行；index 2222的任务6000ms后开始执行，延时200ms后再次执行；index 3333的任务6000ms后开始执行，没间隔200ms后开始执行，间隔是以该任务上次执行结束时开始计算。

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

指定在多久后开始执行，仅执行一次

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

指定多久后开始执行，每个delay的时长后，再次执行，从输出日志可以看到，该调度器在存在足够的线程数的情况下，该任务会存在多个线程同时在执行。

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

指定多久后开始执行，每个执行周期为period，period是从该任务上次结束后开始统计，所以即使线程数足够的清康熙，该任务只有一个线程在执行

1.5  newSingleThreadScheduledExecutor() 

public static ScheduledExecutorService newSingleThreadScheduledExecutor()

说明：该方法与1.4中的Executors.newScheduledThreadPool(1)效果一样

2、直接使用ThreadPoolExecutor类创建线程池，不使用Executors创建线程池

package com.liyong.reactor.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPoolExecutor {
	public static void main(String[] args) {
		// 丢弃老的任务
		RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardOldestPolicy();
		// 将抛出RejectedExecutionException异常
		new ThreadPoolExecutor.AbortPolicy();
		// 调用者自己执行任务
		new ThreadPoolExecutor.CallerRunsPolicy();
		// 丢弃任务
		new ThreadPoolExecutor.DiscardPolicy();
		/*
		 * int corePoolSize 核心线程数
		 * int maximumPoolSize 池中允许的最大线程数 
		 * long keepAliveTime 当线程数大于核心时，这个空闲线程将等待多长时间闲置后被回收
		 * TimeUnit unit 闲置时间单位
		 * BlockingQueue<Runnable> workQueue 任务队列，主要用于设置任务队列深度 
		 * RejectedExecutionHandler handler 任务拒绝策略
		 */
		new ThreadPoolExecutor(8, 64, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), handler);
	}
}

说明： 使用Executors创建的线程池，除了调度线程池外，其他线程池底层都是通过ThreadPoolExecutor来进行构造的。通过自己构造线程池，可以对线程池的各个细节进行设置。

关于拒绝策略：java提供了4中拒绝策略

        // 丢弃老的任务
        new ThreadPoolExecutor.DiscardOldestPolicy();
        // 将抛出RejectedExecutionException异常
        new ThreadPoolExecutor.AbortPolicy();
        // 调用者自己执行任务
        new ThreadPoolExecutor.CallerRunsPolicy();
        // 丢弃任务
        new ThreadPoolExecutor.DiscardPolicy();

但是这4中拒绝策略在我们真正的业务中，其实实用性不是太高。往往可以通过自定义进行优化

优化方案：

从上面的线程池配置中，线程数的配置其实是比较关键的，它直接影响了我们程序运行的效率。那怎么设置一个合适的线程池大小呢？

将被处理的任务分为： CPU密集型的、IO密集型的

如果是CPU密集型的任务，那么就是需要“长时间”占用CPU进行运算的，线程数尽量小，比如配置：CPU 个数 +1 的线程数。

如果是IO密集型的任务，因为IO操作时是不暂用CPU的，尽量不要让CPU闲下来，应尽可能大的增加线程数，比如配置： CPU 个数 * 2 +1。

Runtime.getRuntime().availableProcessors()

可以通过该方法获取当前机器的可用处理器个数。

如果任务对其他资源有依赖，比如从数据库查询数据，从远处服务器拉取数据。等待数据资源时间越长，CPU空闲的时间就越长，所以增加线程数是更好利用CPU的好方法。

因此给出一个估算的公式：

最佳线程数目 = (( 线程等待时间 + 线程 CPU 时间 ) / 线程 CPU 时间 ) * CPU 数目

 将公式进一步化简，得到：

最佳线程数目 = ( 线程等待时间与线程CPU 时间之比+1 ) * CPU 数目

因此得到结论：线程等待时间所占比例越高，需要越多线程。线程 CPU 时间所占比例越高，需要越少线程。 

自定义决绝策略：

package com.liyong.reactor.thread;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {

	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
		//TODO  写日志
		//TODO  发MQ消息
		//TODO  发管理员提醒
		//TODO  executor.getQueue().put(r);  
	}

}

说明：此处只是一段伪代码，主要为了说明在自定义拒绝策略时，可以向系统管理员，以及相关负责人发出警告，这样可以快速进行人工干预，比如：加机器、代码BUG定位等相关操作。

总结：

Java 多线程开发优化有两个思路：

  • 针对锁的优化
  • 线程池优化
霸王凯旋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈线程池的拓容、判断、限速技巧
Java_LingFeng的博客
11-07 406
本文主要分享线程池的动态拓容、判断执行任务执行完毕、线程任务提交速度限制三个线程池使用技巧。
Java多线程之线程池的监控和优化
MRZHQ的博客
02-19 2543
在Java多线程编程中，线程池是一种常见的技术，用于管理线程的创建和销毁。线程池中的线程可以被重复利用，从而减少了线程的创建和销毁的开销，提高了程序的性能。在Java中，线程池的监控和优化也是非常重要的，可以帮助我们更好地管理线程池，提高程序的性能和稳定性。
Java | 如何设置线程池大小？
sinat_27143551的博客
10-28 2453
还记得我说过“线程池的线程数量设置过多会导致线程竞争激烈”吗？今天再补一句，如果线程数量设置过少的话，还会导致系统无法充分利用计算机资源。那么如何设置才不会影响系统性能呢...
java控制线程启动,java线程池:获取运行线程数并控制线程启动速度的方法
weixin_26729841的博客
03-10 254
在java里， 我们可以使用Executors.newFixedThreadPool 来创建线程池， 然后就可以不停的创建新任务，并用线程池来执行了。在提交任务时，如果线程池已经被占满，任务会进到一个队列里等待执行。这种机制在一些特定情况下会有些问题。今天我就遇到一种情况：创建线程比线程执行的速度要快的多，而且单个线程占用的内存又多，所以很快内存就爆了。想了一个办法，就是在提交任务之前，先检查目前...
手把手教你java线程池动态配置调整
欢迎来到我的博客
01-06 4066
解释一下什么是线程池的动态调整？ java程序中使用线程池，在运行过程中动态的调整核心线程数（core_size）、最大线程数（max_size）、存放排队任务的queue大小（blockingQueue size） 为什么会来实现线程池的动态调整？ 来自于美团的公众号“Java线程池实现原理及其在美团业务中的实践”中提到的动态化线程池，看到后眼前一亮，还有这种操作？为什么以前没想到过？所有的技术的方案都是业务所遇到的问题而产生出来的，我想美团应该是流量的不均衡，导致有时需要快速扩充处理能力，而不用发
JAVA 多线程实现、线程池创建使用、多线程的异步操作
javaYY_的博客
07-07 374
目录二、多线程的实现方式（四种）三、线程池的创建使用（五种）1、newFixedThreadPool定长线程池 2、CachedThreadPool可缓存线程池3、newSingleThreadExecutor单线程化线程池4、newScheduledThreadPool周期性线程池无返回值的周期性线程池有返回值的周期性线程池5、ThreadPoolExecutor（手动创建线程池）线程池的submit和execute方法区别进程是:一个应用程序（1个进程是一个软件）。线程是：一个进程中的执行场景/执行单元
【Java 多线程】线程池 —— 详解线程池原理和使用
Moo_Lavender的博客
03-27 336
Java线程池是运用最多的并发框架，学号多线程以及合理的使用多线程可以带来很大的好处，今天就来一起学习线程池相关的知识吧！ 线程池一、线程池的实现原理二、使用线程池1. 使用线程池的好处2.线程池的创建3. 向线程池提交任务4. 关闭线程池 一、线程池的实现原理 当向线程池提交一个任务后，线程池会怎么做呢？ 首先线程池会在核心线程corePoolSize中找是否都在执行任务，如果不是，就创建...
java多线程并发编程 核心技术应用实践
最新发布
06-21
在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的并发机制、线程安全与同步控制、线程池以及实战技巧。 首先，我们需要理解Java中的线程基础。线程是程序执行的最小单位，一个进程可以有多...
java并发编程专题（二）----如何创建并运行java线程
08-18
在Java并发编程中，创建和运行Java线程是核心任务之一。本文将深入探讨两种主要的线程创建方式，以及它们之间的区别。 首先，我们来看第一种方式：继承`Thread`类。`Thread`类是Java中用于表示线程的基类，它实现了...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
java线程池实例详细讲解
08-05
线程池详细讲解的很好实例！
java线程池实例
04-17
java线程池实例java线程池实例E:\Users\Administrator\workspace
使用java的HttpClient实现多线程并发
09-01
为了实现多线程并发，我们需要创建一个`Runnable`任务，该任务用于执行HTTP GET请求： ```java public class GetTask implements Runnable { private final String url; public GetTask(String url) { this.url ...
Java多线程-JDK5.0新增线程创建方式
02-03
### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1：实现Callable接口 ##### （1）介绍 自Java 5.0起，为提高线程管理的灵活性与效率，引入了`Callable`接口，这是一种全新的创建线程的方式。与传统的`...
使用信号量控制线程池任务提交速率的一个坑
镜悬xhs
02-03 639
​0 背景 不久前，标哥（此乃一位技术非常厉害的我的同事）曾让我看过一段很有意思的代码。这段代码的目的是通过信号量控制向线程池中提交任务，避免在线程池中大量积压任务影响程序执行效率。 我简化了一下，大概的逻辑如下： //实际工作的线程数，假设是4 staticfinalintTHREAD_CNT=4; publicstaticvoiddoWork()throwsInterruptedException{ //使用了核心线程数和最大线程数都为4，且使用Synchron...
java 线程管理_Java提供的线程池来创建多线程，进一步优化线程管理。
weixin_42523543的博客
02-16 284
提供最快小儿的阶段是发育生长。根据型德增长模哈罗，程池为(增长率应，为投转化资要使储蓄全部，率为储蓄，本—比为产量若资。在凯主义论中的经济周恩斯期理，建多进关系理的原理乘数和加速原是(。不能现代领导一个化的算是，网络能够科学准确析判对社的、的分断一个通过会舆情做，干部领导，当今时代，报、播、、看看电读书听广除了视外，五习惯”这一“第养成还要上网。把青为另一类草归，、牛给被：鸡童看图画草试儿三幅、青...
Java ExecutorService和线程池
allway2的博客
01-30 230
执行者框架 创建一个或两个线程并运行它们很容易，但是当您的应用程序需要创建20个或30个线程来同时运行任务时，这将成为一个问题。 同样，毫不夸张地说大型多线程应用程序将同时运行数百个（即使不是数千个）线程。因此，将线程的创建和管理与应用程序的其余部分分开是有意义的。 输入执行程序，这是一个用于创建和管理线程的框架。执行器框架可帮助您- 线程创建：它提供了各种创建线程的方法，更具体地说是线程池，您的应用程序可以使用这些方法并发运行任务。 线程管理：它管理线程池中线程的生命周期。在.
java多线程相隔5秒_Java多线程 ThreadPool
weixin_29686935的博客
02-27 445
线程脑图ThreadPool 线程池线程池的构造参数1. corePoolSize:核心线程数2. maximumPoolSize：最大线程数3. keepAliveTime：当线程数，大于核心线程数时，多出来的线程所存活的时间，超过该时间将自动销毁4. unit：keepAliveTime的单位(TimeUnit.SECONDS等)5. workQueue：阻塞队列，用于存放超过核心线程数的Ru...
Java多线程Socket编程示例：使用ExecutorService实现线程池
Java多线程-Socket编程是指使用Java语言编写的多线程编程技术，结合Socket编程来实现客户端和服务器端之间的通信。下面将对Java多线程-Socket编程的知识点进行详细的解释： 多线程编程 多线程编程是指在一个程序中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值