java中的线程执行器总结！

最新推荐文章于 2021-03-04 23:34:20 发布
最新推荐文章于 2021-03-04 23:34:20 发布
阅读量3.4k 收藏 3
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkkkkxiaofei/article/details/19119441
版权

    当需要有大量线程运行时，不可避免的就要反复进行创建，运行，销毁线程，然而显式的这些操作本身都是比较消耗CPU的，必须很好的将这些线程管理起来，如线程池就是一个很好的例子，java提供了许多Executor用以提供对线程的管理。


1.ThreadPoolExecutor


下面程序模拟了利用ThreadPoolExetor来执行10个任务，

public class Program{
	public static void main(String[] agrs){
		Server s=new Server();
		for(int i=0;i<10;i++){
			Task task=new Task(new Date(),"task"+i);
			s.executeTask(task);
		}
		s.endServer();
	}
}

class Task implements Runnable{
	private Date initDate;
	private String name;
	public Task(Date initDate,String name){
		this.initDate=initDate;
		this.name=name;
	}
	@Override
	public void run(){
		System.out.printf("%s: Task %s: Created on: %s\n",Thread.currentThread().getName(),name,initDate);
    System.out.printf("%s: Task %s: Started on: %s\n",Thread.currentThread().getName(),name,new Date());
    try {
			Long duration=(long)(Math.random()*10);
			System.out.printf("%s: Task %s: Doing a task during %d seconds\n",Thread.currentThread().getName(),name,duration);
			TimeUnit.SECONDS.sleep(duration);
			} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.printf("%s: Task %s: Finished on: %s\n",Thread.currentThread().getName(),name,new Date());
	}
	
}

class Server{
	private ThreadPoolExecutor executor;
	public Server(){
		executor=(ThreadPoolExecutor)Executors.newCachedThreadPool();
	}
	
	public void executeTask(Task task){
		System.out.println("a new task has arrived");
		executor.execute(task);
		System.out.printf("Server: Pool Size: %d  Active Count: %d  Completed Tasks: %d\n",executor.getPoolSize(),executor.getActiveCount(),executor.getCompletedTaskCount());
	}
	public void endServer(){
		executor.shutdown();
	}
	
}

执行结果如下：

a new task has arrived
pool-1-thread-1: Task task0: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-1: Task task0: Started on: Wed Feb 12 14:54:12 CST 2014
Server: Pool Size: 1  Active Count: 1  Completed Tasks: 0
pool-1-thread-1: Task task0: Doing a task during 4 seconds
a new task has arrived
Server: Pool Size: 2  Active Count: 1  Completed Tasks: 0
a new task has arrived
pool-1-thread-2: Task task1: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-2: Task task1: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-3: Task task2: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-3: Task task2: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-3: Task task2: Doing a task during 1 seconds
Server: Pool Size: 3  Active Count: 2  Completed Tasks: 0
a new task has arrived
pool-1-thread-2: Task task1: Doing a task during 3 seconds
pool-1-thread-4: Task task3: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-4: Task task3: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-4: Task task3: Doing a task during 3 seconds
Server: Pool Size: 4  Active Count: 3  Completed Tasks: 0
a new task has arrived
Server: Pool Size: 5  Active Count: 4  Completed Tasks: 0
a new task has arrived
pool-1-thread-5: Task task4: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-6: Task task5: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-6: Task task5: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-6: Task task5: Doing a task during 1 seconds
Server: Pool Size: 6  Active Count: 5  Completed Tasks: 0
a new task has arrived
pool-1-thread-5: Task task4: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-7: Task task6: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-7: Task task6: Started on: Wed Feb 12 14:54:12 CST 2014
Server: Pool Size: 7  Active Count: 6  Completed Tasks: 0
a new task has arrived
pool-1-thread-7: Task task6: Doing a task during 0 seconds
pool-1-thread-5: Task task4: Doing a task during 6 seconds
pool-1-thread-7: Task task6: Finished on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-8: Task task7: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-8: Task task7: Started on: Wed Feb 12 14:54:12 CST 2014
Server: Pool Size: 8  Active Count: 7  Completed Tasks: 0
pool-1-thread-8: Task task7: Doing a task during 2 seconds
a new task has arrived
pool-1-thread-7: Task task8: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-7: Task task8: Started on: Wed Feb 12 14:54:12 CST 2014
Server: Pool Size: 8  Active Count: 7  Completed Tasks: 1
a new task has arrived
pool-1-thread-7: Task task8: Doing a task during 6 seconds
Server: Pool Size: 9  Active Count: 8  Completed Tasks: 1
pool-1-thread-9: Task task9: Created on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-9: Task task9: Started on: Wed Feb 12 14:54:12 CST 2014
pool-1-thread-9: Task task9: Doing a task during 8 seconds
pool-1-thread-3: Task task2: Finished on: Wed Feb 12 14:54:13 CST 2014
pool-1-thread-6: Task task5: Finished on: Wed Feb 12 14:54:13 CST 2014
pool-1-thread-8: Task task7: Finished on: Wed Feb 12 14:54:14 CST 2014
pool-1-thread-2: Task task1: Finished on: Wed Feb 12 14:54:15 CST 2014
pool-1-thread-4: Task task3: Finished on: Wed Feb 12 14:54:15 CST 2014
pool-1-thread-1: Task task0: Finished on: Wed Feb 12 14:54:16 CST 2014
pool-1-thread-5: Task task4: Finished on: Wed Feb 12 14:54:18 CST 2014
pool-1-thread-7: Task task8: Finished on: Wed Feb 12 14:54:18 CST 2014
pool-1-thread-9: Task task9: Finished on: Wed Feb 12 14:54:20 CST 2014

注意：

1.当将Runnable对象放入Executor里执行时，当执行完毕后记得要关闭执行器，不然执行器的永久运行将导致程序不会退出（非守护线程不结束，程序是不会结束的）。
2.并不能因为执行器具有较好的线程管理能力而将大量的线程放入线程器里去执行，同样也会拖垮系统。所以在初始化时也可以指定执行器创建线程的容量，如

executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(int number);


 

2.Callable


    Callbale接口主要可以返回线程执行的结果，如当我们开辟多条线程去对数组进行排序时，假若每条线程执行的算法都不同，我们当然希望得到第一个排序完的时间（最优算法），或者我们需要知道每一个算法返回的时间，诸如此类的问题，都需要借助Callable，以下代码模拟了验证用户名和密码，随机返回结果，代码如下

public class Program{
	public static void main(String[] agrs){
		String username="fly";
		String pwd="123456";
		UserValidator v1=new UserValidator("v1");
		UserValidator v2=new UserValidator("v2");
		TaskValidator t1=new TaskValidator(v1,username,pwd);
	  TaskValidator t2=new TaskValidator(v2,username,pwd);
    List<TaskValidator> taskList=new ArrayList<TaskValidator>();
		taskList.add(t1);
		taskList.add(t2);
		ExecuteService es=(ExecuteService)Executors.newCachedThreadPool();
		String result;
		try {
			result = executor.invokeAny(taskList);
			System.out.printf("Main: Result: %s\n",result);
			} catch (InterruptedException e) {
			e.printStackTrace();
			} catch (ExecutionException e) {
			e.printStackTrace();
			}
			executor.shutdown();
		}
		
}

class UserValidator{
	private String name;
	public UserValidator(String name){
		this.name=name;
	}
	
	public boolean validate(String name,String pwd){
		Random random=new Random();
		try {
					long duration=(long)(Math.random()*10);
					System.out.printf("Validator %s: Validating a user during %d seconds\n",this.name,duration);
					TimeUnit.SECONDS.sleep(duration);
					} catch (InterruptedException e) {
					return false;
				}
		return random.nextBoolean();
	}
	
	public String getName(){
		return name;
	}
}

class TaskValidator implements Callable<String>{
	private UserValidator validator;
	private String user;
	private String pwd;
	public TaskValidator(UserValidator validator,String user,String pwd ){
		this.validator=validator;
		this.user=user;
		this.pwd=pwd;
	}
	@Override
	public String call() throws Exception{
		if (!validator.validate(user, password)) {
			System.out.printf("%s: The user has not been found\n",validator.getName());
			throw new Exception("Error validating user");
		}
		System.out.printf("%s: The user has been found\n",validator.getName());
		return validator.getName();
	}
	
}


    Callable实现的步骤其实和直接调用Executor没太大区别，唯一不同的就是，需要将所有的任务放入List列表里，而List的元素类型必须为“? extends Callable”,然后调用类似上面代码的invokeAny(这里是返回第一个任务的结果，还有其他方法，如invokeAll可以返回所有结果为一个集合)。



3.ScheduledThreadPoolExecutor


    ScheduledThreadPoolExecutor可以延迟执行任务，下面程序开启5个任务，分别是1，2，3，4，5秒后自动启动，代码如下：

public class Program{
	public static void main(String[] agrs){
		ScheduledThreadPoolExecutor executor=(ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(1);
		System.out.printf("Main: Starting at: %s\n",new Date());
		for (int i=0; i<5; i++) {
			Task task=new Task("Task "+i);
			executor.schedule(task,i+1 , TimeUnit.SECONDS);
		}
		executor.shutdown();
		try {
			executor.awaitTermination(10, TimeUnit.SECONDS);
			} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.printf("Main: Ends at: %s\n",new Date());
	}
		
}

class Task implements Callable<String>{
	private String name;
	public Task(String name){
		this.name=name;
	}
	@Override
	public String call() throws Exception{
		System.out.printf("%s: Starting at : %s\n",name,new Date());
		return "Hello, world";
	}	
}

    ScheduledThreadPoolExecutor完成delay的效果主要靠，schedule(Callable<T> callable,long delay,TimeUnit t)这个函数完成的，第一个参数也可以是Runnable对象。而shutdown()只是通知虚拟机去关闭执行器，但是若发生任何异常则无法处理，所以需要利用awaitTerimination(long time,TimeUnit t)来等待所有任务完成。shutdown+awaitTermination算是一种优雅的关闭executor的方式了。

 

Java的多线程之执行器
◇″淡定。
02-16 468
构建一个新的线程是有一定代价的，因为涉及与操作系统的交互。如果程序中创建了大量的生命期很短的线程，应该使用线程池(thread pool)。一个线程池中包含许多准备运行的空闲线程。将Runnable对象交给线程池，就会有一个线程调用run方法。当run方法退出时，线程不会死亡，而是在池中准备为下一个请求提供服务。        另一个使用线程池的理由是减少并发线程的数目。创建大量线程会大大降低性
Java多线程案例之任务定时执行器
未见花闻的博客
04-11 2682
本篇文章将介绍Java多线程案例，定时器，定时器就像闹钟一样，等到了指定的时间，闹钟就会发出响声来提醒您，而定时器会执行指定的任务。
java中线程执行器基本知识
hyhanyu的博客
07-27 354
ThreadPoolExecutor：  new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); corePoolSize：除非设置了allowCoreThreadTimeOut，否则即使它们处于空闲状态，也要保留在池中的线程数。 maximumPoolSize：池中允许的最大...
java线程执行器
吴小豪的博客
07-16 312
1.简介： 从Java5开始，java并发API提供了执行器框架(Executor Framwwork)。它围绕Executor接口，ExecutorService接口，以及实现类ThreadPoolExecutor进行展开。该机制分离了任务的创建和运行，我们只需要关注任务的创建，而不需要考虑线程的创建和执行。 2.优势： （1）执行器使用了线程池来提高程序性能，线程重用的优点是减少了创建线
线程执行器
weixin_34344677的博客
06-13 147
通常我们使用JAVA来开发一个简单的并发应用时，会创建一些Runnable对象，然后创建对应的Thread对象来执行他们，但是，如果需要开发一个程序需要运行大量并发任务的时候，这个方法显然不合适。Java提供了执行器框架（Executor Framework）来解决这些问题。Executor Framework机制分离了任务的创建和执行。通过执行器，仅需要实现...
Java中的线程执行器总结
不忘初心 砥砺前行
06-20 306
当需要有大量线程运行时，不可避免的就要反复进行创建，运行，销毁线程，然而显式的这些操作本身都是比较消耗CPU的，必须很好的将这些线程管理起来，如线程池就是一个很好的例子，java提供了许多Executor用以提供对线程的管理。 1.ThreadPoolExecutor 下面程序模拟了利用ThreadPoolExetor来执行10个任务， [java] vi
Java多线程知识点总结
08-19
Java多线程是Java编程语言中一个非常重要的概念，它允许开发者在一个程序中创建多个执行线程并行运行，以提高程序的执行效率和响应速度。在Java中，线程的生命周期包含五个基本状态，分别是新建状态（New）、就绪...
Java多线程编程总结
01-14
#### 二十、Java线程：新特征-障碍器 - `CyclicBarrier` 和 `Phaser` 类允许一组线程相互等待，直到所有线程到达一个公共的障碍点。 通过以上总结，我们可以看出Java5之后对多线程的支持有了极大的提升，引入了一...
Java多线程相关知识总结
最新发布
03-15
// 线程执行的逻辑 } } ``` #### 三、线程控制 1. **设置和获取线程名**： - 可以通过`Thread`对象的`setName`方法设置线程名称，通过`getName`方法获取线程名称。 - 如果未显式设置线程名称，则默认名称...
Java中实现线程的超时中断方法实例
08-27
Java中实现线程的超时中断方法实例 概述：在 Java 中实现线程的超时中断是非常重要的，特别是在熔断降级组件中。熔断降级组件需要在指定的超时时间内中断请求线程，以避免请求长时间阻塞系统资源。在这篇文章中，...
Java™ 教程（执行器）
weixin_33774615的博客
01-18 285
执行器 在前面的所有示例中，由新的线程（由其Runnable对象定义）和线程本身（由Thread对象定义）完成的任务之间存在紧密的联系，这适用于小型应用程序，但在大型应用程序中，将线程管理和创建与应用程序的其余部分分开是有意义的，封装这些函数的对象称为执行器，以下小节详细描述了执行器。 执行器接口定义三个执行器对象类型。 线程池是最常见...
Java 线程执行器 详解
chenshun123的博客
09-11 1177
线程执行器 分离任务的创建和执行，通过食用执行器，仅需要使用 Runnable接口对象然后将这些对象发送给执行器即可。执行器通过创建所需线程，来负责这些 Runnable对象的创建、实例化以及运行。当一个任务发送给执行器，执行器会尝试使用线程池中的线程来执行这个任务，避免不断地创建、销毁线程而导致系统性能下降 执行框架，有 Callable接口功能类似于 Runnable 接口，但是功能
java执行器是什么_【翻译十九】-java之执行器
weixin_35697297的博客
02-16 472
In all of the previous examples, there's a close connection between the task being done by a new thread, as defined by itsRunnableobject, and the thread itself, as defined by aThreadobject. This wo...
java执行器是什么_java+spring 执行器
weixin_39541189的博客
02-13 498
A 通过MethodInvokingJobDetailFactoryBean类实现spring配置文件里增加执行器配置1 23 4 5 6 7 8 excute9 10 11 false12 1314 1516 ...
java 单线程执行器_Java基础-并发编程-线程执行器executor
weixin_29384861的博客
03-04 246
线程实现方式Thread、Runnable、Callable//实现Runnable接口的类将被Thread执行，表示一个基本任务public interface Runnable {//run方法就是它所有内容，就是实际执行的任务public abstract void run();}//Callable同样是任务，与Runnable接口的区别在于它接口泛型，同时它执行任务候带有返回值；//Ca...
java语言的执行器_Java并发中的执行器Executor/ExecutorService和ExecutorCompletionService | 三石·道...
weixin_42514921的博客
02-24 280
上篇文章讲到了Callable和Futre，这篇文章接着来说说执行器相关的接口和类。在JavaSE5之后，在API的java.util.concurrent包中给出了Executor这样一个接口。因为在Java7之前，JDK中这个接口最终都是以一个线程池ThreadPool的方式实现的，所以很多人也直接叫“线程池”。除了ThreadPool之外，还有ForkJoinPool实现，本文中，我们不妨直...
java执行器是什么_Java 并发编程：任务执行器 Executor 接口
weixin_30302513的博客
02-16 330
任务执行器(Executor)是一个接口，位于java.util.concurrent包下，它的作用主要是为我们提供任务与执行机制(包括线程使用和调度细节)之间的解耦。比如我们定义了一个任务，我们是通过线程池来执行该任务，还是直接创线程来执行该任务呢？通过Executor就能为任务提供不同的执行机制。执行器的实现方式各种各样，常见的包括同步执行器、一对一执行器、线程池执行器、串行执行器等等。下面我...
Java多线程 之 执行器Executor（二）
程序员
06-01 1054
java多线程很少像前面的例子那样直接使用Thread.start()方法来驱动。而是使用执行器Executor来管理线程。执行器是启动任务的最佳方法。 ExecutorService（一个具有服务生命周期的执行器）知道如何创建恰当的上下文来执行Runnable对象。请看下面的例子（其中LiftOff参见上一篇文章）：package org.fan.learn.thread; import jav
Java多线程编程学习总结与实例解析
Java 多线程是 Java 程序设计中的一项核心技术，它允许程序中同时执行多个线程，提高资源利用率，简化复杂任务的实现。本资源是一份关于 Java 多线程的综合学习总结文档，适用于有一定 Java 基础的程序员和对多线程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值