四种线程池

最新推荐文章于 2024-07-26 22:36:20 发布
最新推荐文章于 2024-07-26 22:36:20 发布
阅读量2.1k 收藏 2
点赞数
分类专栏： java细节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/time_hunter/article/details/53282508
版权

newCachedThreadPool用法

代码

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

public class TestMain {

	public static void main(String[] args) {
		
		ExecutorService cachedService = Executors.newCachedThreadPool();
		
		for( int i = 0; i < 100; i ++) {
			cachedService.execute(new MyThread(i));
		}
		cachedService.shutdown();
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(" Thread-" + Thread.currentThread().getName() + "  " + index);;
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				
			}
		}
		
	}

}

输出



特点

  • 会根据需要创建新线程，如果线程池中有可复用的，会先服用可用的。
  • 这个线程池典型的场景是改善 任务耗时短小的 异步任务。
  • 使用execute可以复用可用的线程。如果没有可用线程，会创建新线程并添加到线程池里。
  • 那些1分钟没有被使用的线程将被停止并从缓存里移除。

newCachedThreadPool实现

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

可知

  • corePoolSize 为 0
  • maxPoolSize 为 Integer.MAX_VALUE。 无限大
  • keepAliveTime为 60 秒，便是 maxPoolSize - corePoolSize的那些线程可以存活的idle时间

newFixedThreadPool(int threadCount)

代码

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

public class TestMain {

	public static void main(String[] args) {
		
		// case 2 --------------------------------
		
		ExecutorService fixedService2 = Executors.newFixedThreadPool(5);
		for ( int i = 0; i < 20; i ++) {
			fixedService2.execute(new MyThread(i));
		}
		
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(" Thread-" + Thread.currentThread().getName() + "  " + index);;
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				
			}
		}
		
	}

}

输出


特点

  • 可以复用指定数目的线程
  • 如果请求的线程数目大于目前idle的，那么多余的请求将被等待，直到线程池中有可用的线程。
  • 如果有任何线程执行过程中停止了，将会新建一个线程代替。
  • 线程池中的线程一直存活，直到显式的使用shutdown关闭。

newFixedThreadPool实现

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
可知

  • corePoolSize 为指定大小
  • maxPoolSize 也为指定大小
  • keepAliveTime 为0，因为corePoolSize 与 maxPoolSize相同，所以并不影响

newScheduledThreadPool

定时延迟 + 循环执行 实例代码

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestMain {

	public static void main(String[] args) {
		
		int j = 0;
		// case 3 -------------------------------
		System.out.println( "  " + getDateStr() + " start ");
		ScheduledExecutorService scheduledService3 = Executors.newScheduledThreadPool(1);
		scheduledService3.scheduleAtFixedRate(new MyThread(j++), 5, 20, TimeUnit.SECONDS);
		
		scheduledService3.scheduleAtFixedRate(new MyThread(j++), 3, 20, TimeUnit.SECONDS);
		
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  ");
		}
		
	}
	
	public static String getDateStr() {
	       Date date = new Date();  
        

	       SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

               return sdf.format(date);
       }
}

输出

延迟执行

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestMain {

	public static void main(String[] args) {
		
		
		int j = 0;
		// case 3 -------------------------------
		System.out.println( "  " + getDateStr() + " start ");
		ScheduledExecutorService scheduledService3 = Executors.newScheduledThreadPool(1);
		
		scheduledService3.schedule(new MyThread(j++), 5, TimeUnit.SECONDS);
		
		scheduledService3.schedule(new MyThread(j++), 15, TimeUnit.SECONDS);
		
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  ");
		}
		
	}
	
	public static String getDateStr() {
		Date date = new Date();  
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                return sdf.format(date);
	}

}

输出


newScheduledThreadPool的实现

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

scheduleAtFixedRate特点

  • 支持定时及循环任务执行
  • 延迟定时，延迟的时间间隔是从调用开始开始计算的，并不受线程执行时间长短的影响
关于scheduleAtFixedRate schedule的时间并不受所执行时间长短的影响 

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestMain {

	public static void main(String[] args) {	
		
		int j = 0;
		// case 3 -------------------------------
		System.out.println( "  " + getDateStr() + " start ");
		ScheduledExecutorService scheduledService3 = Executors.newScheduledThreadPool(1);

		scheduledService3.scheduleAtFixedRate(new MyThread(j++), 10, 10, TimeUnit.SECONDS);

	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  +++++");
			
			try {
				Thread.sleep(8000);
			} catch (Exception e) {
				
			}
			
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  -----");
		}
		
	}
	
	public static String getDateStr() {
		Date date = new Date();  
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                return sdf.format(date);
	}

}

输出

scheduleWithFixedDelay：线程执行完毕开始计算，指定的delay的时间后执行

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestMain {

	public static void main(String[] args) {
		
		int j = 0;
		// case 3 -------------------------------
		System.out.println( "  " + getDateStr() + " start ");
		ScheduledExecutorService scheduledService3 = Executors.newScheduledThreadPool(1);

		scheduledService3.scheduleWithFixedDelay(new MyThread(j++), 10, 10, TimeUnit.SECONDS);
		
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  +++++");
			
			try {
				Thread.sleep(8000);
			} catch (Exception e) {
				
			}
			
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() + "  -----");
		}
		
	}
	
	public static String getDateStr() {
		Date date = new Date();  
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                return sdf.format(date);
	}

}

输出


newSingleThreadScheduledExecutor

代码

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestMain {

	public static void main(String[] args) {
		
		// case 4 -------------------------------
		int a = 0;
		ExecutorService singleThreadService = Executors.newSingleThreadExecutor();

		singleThreadService.execute(new MyThread(a++));
		singleThreadService.execute(new MyThread(a++));
		singleThreadService.execute(new MyThread(a++));
		
	}
	
	public static class MyThread implements Runnable {
		
		public int index;
		
		public MyThread (int index) {
			this.index = index;
		}

		@Override
		public void run() {
			System.out.println(index + " " + getDateStr() + "  Thread-" + Thread.currentThread().getName() );
			
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				
			}
		}
		
	}
	
	public static String getDateStr() {
		Date date = new Date();  
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                return sdf.format(date);
	}

}

输出


实现

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

特点

  • corePoolSize = 1  maxPoolSize = 1;
  • 最多只开启一个线程，对于队列中的Runnable，挨个执行

线程池的关闭

shutdown代码

		int a = 0;
		ExecutorService singleThreadService = Executors.newSingleThreadExecutor();

		singleThreadService.execute(new MyThread(a++));
		singleThreadService.execute(new MyThread(a++));
		singleThreadService.execute(new MyThread(a++));
		System.out.println("main  " + getDateStr() + "  shutdown ");
		singleThreadService.shutdown();

shutdown输出


shutdown特点

  • 等待已经有的线程执行完毕
  • 新附加的任务不再执行

四种实现的参数设置

 cachedThreadPoolfixedThreadPoolsingleThreadPoolscheduledThreadPool
corePoolSize0指定的大小1指定的大小
maxPoolSizeInteger.Max同corePoolSize1无实际意思（目前）
keepAliveTime60秒无实际意义无实际意义0







time_hunter
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池（框图）
z_cqupt的博客
09-20 552
先上几张我画的图，后续有时间会将代码进行分析。供大家参考 1.线程所调用的函数 2.线程池整体框架图： 线程池描述结构 线程初始化 线程处理函数： ...
Java中四种线程池
weixin_55830623的博客
06-30 159
​ 线程池Executors 线程池的好处 Java中的四种线程池 . ExecutorService 缓存线程池 package lesson4_5; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Demo15 { /** * 缓存线程池 * （长度无限制） * 任务加入后的执行流程 * ..
四大线程池详解
热门推荐
Zero
08-30 3万+
new Thread 的弊端首先看一段代码：/** * Created by Zero on 2017/8/30. */ public class ThreadTest { public static void main(String[] args) { while (true) { new Thread(new Runnable() {
Java—常见4种线程池详解
最新发布
weixin_44991038的博客
07-26 1236
java中常见4种线程池—SingleThreadExecutor、FixedThreadPool、CacheThreadPool、ScheduledThreadPool
四种常用线程池
lhd992692552的博客
01-17 4690
一、newCachedThreadPool public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue
Executors提供的四种线程池
weixin_30349597的博客
05-25 119
Executors提供的四种线程池 转载于:https://www.cnblogs.com/longshiyVip/p/6902721.html
4. 线程池
DiKeLuoNa
01-12 78
线程池
Java ExecutorService四种线程池使用详解
08-28
下面将详细介绍这四种线程池的特点和使用场景。 1. **newCachedThreadPool** `newCachedThreadPool` 创建的是一个可缓存线程池。当线程池中的线程数量超过处理任务的需要时，空闲线程会被回收。如果线程池中没有...
Java中四种线程池的使用示例详解
08-29
【Java中的四种线程池详解】 Java中的线程池提供了高效管理并发任务的机制，它通过维护一组可重用的工作线程来减少线程创建和销毁的开销。本文将详细介绍Java中的四种线程池：FixedThreadPool、CachedThreadPool、...
对 Java 四种线程池的简要分析
12-21
Java提供了四种内置的线程池实现： 1. **newCachedThreadPool**： 这是一个可缓存线程池。它会重用以前创建的线程，如果线程池为空，新任务将创建一个新的线程。线程池的大小没有上限，最大值为`Integer.MAX_VALUE...
Java四种线程池的使用共6页.pdf.zip
10-29
本资料"Java四种线程池的使用共6页.pdf.zip"详细介绍了Java中四种主要的线程池实现，旨在帮助开发者更有效地利用系统资源，提高程序性能。 首先，我们要了解Java线程池的基本概念。线程池是一种线程使用模式，通过...
Java四种线程池的简单介绍.docx
06-28
### Java 四种线程池的详细介绍 #### 1. `newCachedThreadPool`：创建一个可缓存线程池 - **定义与特点**： - `newCachedThreadPool` 创建了一个可缓存线程池，它能够根据当前的处理需求灵活调整线程数量。 - 当...
4种线程池详解
wh柒八九的博客
04-22 2224
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。 文章目录ExecutorService概述 ExecutorService概述 Java 里面线程池的顶级接口是 Executor，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 ExecutorService。 Java通过Executors工厂类提供四种线程池，分别为： .
常见的4种线程池
javaZhong的博客
03-04 6884
1、newCachedThreadPool： /** * 一个可缓存线程池，如果线程池长度超过需要处理需要，可灵活回收空闲线程，若无可回收，则新建线程 * 适合短时间的任务 * 缺点：要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。 */ 2、newFixedThreadPool： /** * 定长线程池，可以控制线程最大并发数，超出的任务会在队列中等待 * 缺点：要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。 */
四大线程池
weixin_33872660的博客
11-13 73
2019独角兽企业重金招聘Python工程师标准>>> ...
Java内置四种线程池详解
"Java内置的四种线程池主要为开发者提供了不同特性的线程管理方案，包括newSingleThreadExecutor、newFixedThreadPool、newCacheThreadPool和newScheduledThreadPool。这些线程池都是基于ThreadPoolExecutor实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值