线程池

最新推荐文章于 2022-08-14 22:46:20 发布
最新推荐文章于 2022-08-14 22:46:20 发布
阅读量134 收藏
点赞数
分类专栏： 高并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jue6628/article/details/108988140
版权
一、为什么要用线程池

1、频繁的创建、启动、关闭线程消耗大量的系统资源
2、提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
3、方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OutOfMemonry，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。
4、提供更强大的功能，延时定时线程池。

二、线程池原理

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

三、线程池主要参数
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler);
  • corePoolSize 核心线程数：当线程池线程数小于核心线程数时，会接到一个任务创建一个线程，不会重复利用闲置线程，直至创建到核心线程数时。
  • maximumPoolSize 最大线程数：当前线程池可以创建的最大的线程数量
  • keepAliveTime 线程闲暇存活时间：当线程数大于核心线程数时，闲暇的线程按照这个时间关闭线程
  • unit 线程闲暇时间存活的单位：
  • workQueue：队列用于存储任务
  • threadFactory 线程工厂：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号
  • handler 拒绝策略：当线程池线程数达到最大并且队列也满了，就会执行拒绝策略（系统默认是抛出异常）；
四、线程池工作流程：在这里插入图片描述
  1. 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
  2. 当调用 execute() 方法添加一个任务时，线程池会做如下判断：

a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建新线程运行这个任务；
b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
c) 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
d) 如果队列满了，而且正在运行的线程数量等于 maximumPoolSize，那么线程池会抛出异常 RejectExecutionException。
3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。
4. 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

	/**
	 * 测试： 提交15个执行时间需要3秒的任务,看线程池的状况
	 * 
	 * @param threadPoolExecutor 传入不同的线程池，看不同的结果
	 * @throws Exception
	 */
	public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 查看线程数量，查看队列等待数量
		Thread.sleep(500L);
		System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
		System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
		// 等待15秒，查看线程数量和队列数量（理论上，会被超出核心线程数量的线程自动销毁）
		Thread.sleep(15000L);
		System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
		System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
	}


/**
	 * 2、 线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest2() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		testCommon(threadPoolExecutor);
		// 预计结果：
		// 1、 5个任务直接分配线程开始执行
		// 2、 3个任务进入等待队列
		// 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁)
		// 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。
		// 5、 任务执行，5秒后，如果无任务可执行，销毁临时创建的5个线程
	}

任务提交成功 :0
任务提交成功 :1
任务提交成功 :2
任务提交成功 :3
任务提交成功 :4
任务提交成功 :5
任务提交成功 :6
任务提交成功 :7
任务提交成功 :8
任务提交成功 :9
任务提交成功 :10
任务提交成功 :11
任务提交成功 :12
有任务被拒绝执行了
任务提交成功 :13
有任务被拒绝执行了
任务提交成功 :14
当前线程池线程数量为：10
当前线程池等待的数量为：3
执行结束:0
执行结束:4
执行结束:1
执行结束:3
执行结束:2
执行结束:11
执行结束:12
执行结束:9
执行结束:10
执行结束:8
执行结束:5
执行结束:6
执行结束:7
当前线程池线程数量为：5
当前线程池等待的数量为：0
五、拒绝策略

DiscardPolicy：丢弃无法处理的任务
AbortPolicy：抛出异常，阻止提交任务线程（任务线程正常执行，不受影响）
DiscardOldestPolicy：线程池未关闭情况下，丢弃当前将要执行的任务，然后将任务提交到队列中
CallerRunsPolicy：线程池未关闭的情况下，将让任务提供线程执行任务

六、四种常用线程池

在这里插入图片描述
newFixedThreadPool

/**
 * 3、 线程池信息： 核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：5秒
 * 
 * @throws Exception
 */
private void threadPoolExecutorTest3() throws Exception {
	// 和Executors.newFixedThreadPool(int nThreads)一样的
	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
			new LinkedBlockingQueue<Runnable>());
	testCommon(threadPoolExecutor);
	// 预计结：线程池线程数量为：5，超出数量的任务，其他的进入队列中等待被执行
}

newCachedThreadPool

**
 * 4、 线程池信息：
 * 核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列，超出核心线程数量的线程存活时间：60秒
 * 
 * @throws Exception
 */
private void threadPoolExecutorTest4() throws Exception {

	// SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。
	// 在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时，
	// 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务，
	// 那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。
	// 此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize）。

	// 和Executors.newCachedThreadPool()一样的
	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
			new SynchronousQueue<Runnable>());
	testCommon(threadPoolExecutor);
	// 预计结果：
	// 1、 线程池线程数量为：15，超出数量的任务，其他的进入队列中等待被执行
	// 2、 所有任务执行结束，60秒后，如果无任务可执行，所有线程全部被销毁，池的大小恢复为0
	Thread.sleep(60000L);
	System.out.println("60秒后，再看线程池中的数量：" + threadPoolExecutor.getPoolSize());
}

newScheduledThreadPool

	/**
	 * 5、 定时执行线程池信息：3秒后执行，一次性任务，到点就执行 <br/>
	 * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest5() throws Exception {
		// 和Executors.newScheduledThreadPool()一样的
		ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
		threadPoolExecutor.schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println("任务被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 3000, TimeUnit.MILLISECONDS);
		System.out.println(
				"定时任务，提交成功，时间是：" + System.currentTimeMillis() + ", 当前线程池中线程数量：" + threadPoolExecutor.getPoolSize());
		// 预计结果：任务在3秒后被执行一次
	}

newSingleThreadExecutor
创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

七、其他api对比

scheduleAtFixedRate 和 scheduleWithFixedDelay

/**
	 * 6、 定时执行线程池信息：线程固定数量5 ，<br/>
	 * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest6() throws Exception {
		ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
		// 周期性执行某一个任务，线程池提供了两种调度方式，这里单独演示一下。测试场景一样。
		// 测试场景：提交的任务需要3秒才能执行完毕。看两种不同调度方式的区别
		// 效果1： 提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，完毕后立刻执行)。
		// 也就是说这个代码中是，3秒钟执行一次（计算方式：每次执行三秒，间隔时间1秒，执行结束后马上开始下一次执行，无需等待）
		threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(3000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("任务-1 被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 2000, 1000, TimeUnit.MILLISECONDS);

		// 效果2：提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，等上一次执行完毕后再开始计时，等待1秒)。
		// 也就是说这个代码钟的效果看到的是：4秒执行一次。 （计算方式：每次执行3秒，间隔时间1秒，执行完以后再等待1秒，所以是 3+1）
		threadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(3000L);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("任务-2 被执行，现在时间：" + System.currentTimeMillis());
			}
		}, 2000, 1000, TimeUnit.MILLISECONDS);
	}

shutdown

	/**
	 * 7、 终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest7() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("开始执行：" + n);
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						System.out.println("异常：" + e.getMessage());
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 1秒后终止线程池
		Thread.sleep(1000L);
		threadPoolExecutor.shutdown();
		// 再次提交提示失败
		threadPoolExecutor.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("追加一个任务");
			}
		});
		// 结果分析
		// 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
		// 2、调用shutdown后，不接收新的任务，等待13任务执行结束
		// 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行
	}

任务提交成功 :0
任务提交成功 :1
任务提交成功 :2
任务提交成功 :3
任务提交成功 :4
任务提交成功 :5
任务提交成功 :6
任务提交成功 :7
任务提交成功 :8
任务提交成功 :9
任务提交成功 :10
任务提交成功 :11
任务提交成功 :12
有任务被拒绝执行了
任务提交成功 :13
有任务被拒绝执行了
任务提交成功 :14
开始执行：0
开始执行：1
开始执行：3
开始执行：4
开始执行：2
开始执行：9
开始执行：8
开始执行：10
开始执行：11
开始执行：12
有任务被拒绝执行了
执行结束:0
开始执行：5
执行结束:4
执行结束:3
开始执行：6执行结束:1

开始执行：7
执行结束:9
执行结束:2
执行结束:8
执行结束:10
执行结束:12
执行结束:11
执行结束:5
执行结束:6
执行结束:7

shutdownNow

	/**
	 * 8、 立刻终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
	 * 
	 * @throws Exception
	 */
	private void threadPoolExecutorTest8() throws Exception {
		// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
		// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
					@Override
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.err.println("有任务被拒绝执行了");
					}
				});
		// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
		for (int i = 0; i < 15; i++) {
			int n = i;
			threadPoolExecutor.submit(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println("开始执行：" + n);
						Thread.sleep(3000L);
						System.err.println("执行结束:" + n);
					} catch (InterruptedException e) {
						System.out.println("异常：" + e.getMessage());
					}
				}
			});
			System.out.println("任务提交成功 :" + i);
		}
		// 1秒后终止线程池
		Thread.sleep(1000L);
		List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow();
		// 再次提交提示失败
		threadPoolExecutor.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("追加一个任务");
			}
		});
		System.out.println("未结束的任务有：" + shutdownNow.size());

		// 结果分析
		// 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
		// 2、调用shutdownnow后，队列中的3个线程不再执行，10个线程被终止
		// 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行
	}


任务提交成功 :0
任务提交成功 :1
任务提交成功 :2
任务提交成功 :3
任务提交成功 :4
任务提交成功 :5
任务提交成功 :6
任务提交成功 :7
任务提交成功 :8
任务提交成功 :9
任务提交成功 :10
任务提交成功 :11
任务提交成功 :12
有任务被拒绝执行了
任务提交成功 :13
有任务被拒绝执行了
任务提交成功 :14
开始执行：1
开始执行：0
开始执行：2
开始执行：3
开始执行：4
开始执行：8
开始执行：9
开始执行：10
开始执行：11
开始执行：12
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
异常：sleep interrupted
有任务被拒绝执行了
未结束的任务有：3
八、execute()和submit()方法

1、execute()，执行一个任务，没有返回值。
2、submit()，提交一个线程任务，有返回值。
submit(Callable task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（IntentService中有体现）。

submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。
submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null。

Future.get方法会使取结果的线程进入阻塞状态，直到线程执行完成之后，唤醒取结果的线程，然后返回结果

九、如何确定合适的线程数量

在这里插入图片描述

详情
使用讲解
参考

欲滴007
关注
专栏目录
13.ThreadPoolExecutor线程池之submit方法
weixin_33754913的博客
06-17 652
jdk1.7.0_79  　　在上一篇《ThreadPoolExecutor线程池原理及其execute方法》中提到了线程池ThreadPoolExecutor的原理以及它的execute方法。本文解析ThreadPoolExecutor#submit。 　　对于一个任务的执行有时我们不需要它返回结果，但是有我们需要它的返回执行结果。对于线程来讲，如果不需要它返回结果则实现Runnable，而...
一文理解ThreadPoolExecutor线程池以及运行时间
最新发布
heromps的博客
07-18 1140
核心线程数（corePoolSize）线程池中保持的核心线程数量。即使这些线程处于空闲状态，它们也不会被销毁，除非设置了。最大线程数（maximumPoolSize）线程池中允许的最大线程数量。当工作队列已满且请求数超过核心线程数时，线程池会创建新线程，直到总线程数达到最大线程数。工作队列（workQueue）用于保存等待执行的任务的队列。常用的队列类型有等。线程工厂（ThreadFactory）用于创建新线程的工厂，可以定制线程的创建过程，例如设置线程名称、优先级等。
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
下面小编就为大家带来一篇简单谈谈ThreadPoolExecutor线程池之submit方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
c++ socket线程池原理_线程池续：你必须要知道的线程池submit()实现原理之FutureTask
weixin_39818521的博客
11-25 365
前言讲解线程提交的submit()方法，submit()有一个返回值，可以获取线程执行的结果Future，这一讲就那深入学习下submit()和FutureTask实现原理。使用场景&示例使用场景我能想到的使用场景就是在并行计算的时候，例如一个方法中调用methodA()、methodB()，我们可以通过线程池异步去提交方法A、B，然后在主线程中获取组装方法A、B计算后的结果，能够大大提升...
线程池 submit 和 execute
热门推荐
好记性不如烂博客
11-10 1万+
public class RunnableTestMain {     public static void main(String[] args) {         ExecutorService pool = Executors.newFixedThreadPool(2);                 /**          * execute(Runnable x
线程池submit和execute方法原理
kai3123919064的博客
05-19 8523
线程池的作用 : 1. 避免大量的线程强占资源 2. 避免大量的线程创建和销毁带来的开销 线程池的原理 : 创建线程池的时候,可以使用executors的静态方法,也可以使用new ThreadPoolExecutor的方式手动创建线程池,通过在线程池中指定参数达到创建不同类型的线程池的效果 其中,executors底层其实也是调用的new ThreadPoolExecutor()的方式创...
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
一、要实现高效的线程池，可以考虑以下几点 二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用阿里巴巴开源的EasyExcel库结合线程池技术可以有效地实现从Excel文件导入到数据库的过程。先定义sheet的数量和固定大小的线程池数量，每个sheet页做为单独的任务交给线程池...
阻塞线程池 阻塞线程池 阻塞线程池
04-18
阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池...
多线程写法（精易模块线程池和鱼刺模块线程池）
06-02
本篇文章将重点探讨两种线程池实现：精易模块线程池和鱼刺模块线程池，并通过源码分析来展示它们的特点和用法。 首先，精易模块（SanYe Module）是由中国程序员SanYe开发的一系列开源模块，其中包含了线程池的实现...
java线程池_submit()
weixin_44613100的博客
06-10 5985
submit()方法 有三个重载方法： submit（Callable<T> task）//参数为Callable接口的实现类的实例 submit(Runnable task, T result)//第二个参数为默认值 submit(Runnable task) 线程池测试类 package com.thread.pool; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor
java 线程池以及submit
一只摸爬滚打的it狗
08-04 771
突然发现自己老啦 都要开始记笔记了   线程这块看了好几遍 都没记住~~ 索性看一点记一点好咯 们可能还会有以下需求： 1、需要取消某个任务的运行  （可以设置全局变量） 2、需要接收任务运行的结果 3、需要在一个任务出错时候，停止未运行任务的运行（通过抛出异常，捕获异常则可以继续运行） 那么我们会用到线程池的 submit 方法，我们的任务需要实现Callable接
Java 线程池的submit的使用与分析.md
AndyCat的知识库
01-25 6977
在Java5以后，通过Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。我们用的最多的execute方法， 0.异步返回值的场景 我们先不用线程池，来实现一个功能。加入周末了，几个小伙伴要一块做饭，假设做饭需要3个步骤，分别是： 1.打扫厨房卫生，准备厨具 2.买菜 3.炒菜 现在我们怎么分工呢，现实...
线程池（三）----ThreadPoolTaskExecutor的提交方法execute和submit
这个人很懒，什么都没有留下。
07-29 1万+
线程池（三）----ThreadPoolTaskExecutor的提交方法execute和submit
线程池-两种提交任务的方法execute()与submit()详解
张念磊的博客
12-10 1万+
引言 线程池中有两个提交任务的方法 向线程池提交任务的两种方式大致如下： 方式一：调用execute()方法 // todo 源码 方式二：调用submit()方法 // todo 源码 一、区别 以上的submit()和execute()两类方法的区别在哪里呢？大致有以下三点： 1.二者所接收的参数不一样 Execute()方法只能接收Runnable类型的参数，而submit()方法可以接收Callable、Runnable两种类型的参数。Callable类型的任务是可以返回执行结果的，而Runnabl
java_多线程——线程池、submit和execute区别
qq_59727955的博客
08-14 3296
线程池、submit和execute区别
java线程池存在时间_Java线程池基础
weixin_31766871的博客
02-28 1923
目录：一、线程池概述1、线程池类目前线程池类一般有两个，一个来自于Spring，一个来自于JDK：来自Spring的线程池：org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor来自JDK的线程池：java.util.concurrent.ThreadPoolExecutor说明：两个线程池类中的参数【线程池最大线程数】写法...
C语言实现线程池详解
"C语言实现线程池的代码示例" C实现线程池是一种优化多线程程序性能的方法，它允许程序预先创建一组线程，然后根据需要调度这些线程执行任务，而不是每次需要时都创建新的线程。线程池通过减少线程创建和销毁的开销...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值