Java并发包中的几种ExecutorService

1.CachedThreadPool

    CachedThreadPool首先会按照需要创建足够多的线程来执行任务(Task)。随着程序执行的过程,有的线程执行完了任务,可以被重新循环使用时,才不再创建新的线程来执行任务。我们采用《Thinking In Java》中的例子来分析。

    首先,任务定义如下(实现了Runnable接口,并且复写了run方法):

        public class LiftOff implements Runnable{   
                protected int countDown = 10; //Default   
                private static int taskCount = 0;   
                private final int id = taskCount++;    
                public LiftOff() {}   
                public LiftOff(int countDown) {   
                    this.countDown = countDown;   
                }   
                public String status() {   
                    return "#" + id + "(" +   
                        (countDown > 0 ? countDown : "LiftOff!") + ") ";   
                }   
                @Override   
                public void run() {   
                    while(countDown-- > 0) {   
                        System.out.print(status());   
                        Thread.yield();   
                    }   
                       
                }

      }

采用CachedThreadPool方式执行编写的客户端程序如下:
           public class CachedThreadPool {   
                public static void main(String[] args) {   
                    ExecutorService exec = Executors.newCachedThreadPool();   
                    for(int i = 0; i < 10; i++) {   
                        exec.execute(new LiftOff());   
                    }   
                    exec.shutdown();       
                }   
            }

上面的程序中,有10个任务,采用CachedThreadPool模式,exec没遇到一个LiftOff的对象(Task),就会创建一个线程来处理任务。现在假设遇到到第4个任务时,之前用于处理第一个任务的线程已经执行完成任务了,那么不会创建新的线程来处理任务,而是使用之前处理第一个任务的线程来处理这第4个任务。接着如果遇到第5个任务时,前面那些任务都还没有执行完,那么就会又新创建线程来执行第5个任务。否则,使用之前执行完任务的线程来处理新的任务。

2.FixedThreadPool

FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。规定数目的线程处理所有任务,一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。这种模式与上面的CachedThreadPool是不同的,CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。而FixedThreadPool模式下最多的线程数目是一定的。

采用FixedThreadPool模式编写客户端程序如下:

public class FixedThreadPool {   
 public static void main(String[] args) {  
  //三个线程来执行五个任务   
   ExecutorService exec = Executors.newFixedThreadPool(3);      
   for(int i = 0; i < 5; i++) {   
     exec.execute(new LiftOff());   
   }   
   exec.shutdown();   
  }   
}

3.SingleThreadExecutor模式

SingleThreadExecutor模式只会创建一个线程。它和FixedThreadPool比较类似,不过线程数是一个。如果多个任务被提交给SingleThreadExecutor的话,那么这些任务会被保存在一个队列中,并且会按照任务提交的顺序,一个先执行完成再执行另外一个线程。

SingleThreadExecutor模式可以保证只有一个任务会被执行。这种特点可以被用来处理共享资源的问题而不需要考虑同步的问题。

SingleThreadExecutor模式编写的客户端程序如下: 

public class SingleThreadExecutor {   
  public static void main(String[] args) {   
    ExecutorService exec = Executors.newSingleThreadExecutor();   
    for (int i = 0; i < 2; i++) {   
       exec.execute(new LiftOff());   
    }   
  }   
}

#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(LiftOff!)

#1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(LiftOff!)
第一个任务执行完了之后才开始执行第二个任务。



例子:

Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

public class ExecutorTest {
/*public Executor executor;
public ExecutorService executorService;
Future<String> fu;
Callable<String> call;
CompletionService<String> com;
Executors executors;*/

public static void main(String []ages) throws Exception{
	newFixedThreadPoolTest();
	/*newFixedThreadPoolTest();
	newFixedThreadPoolTest();*/
	newCachedThreadPoolTest();
	newSingleThreadExecutorTest();
	newScheduledThreadPoolTest();
	System.out.println("完成");
}
private static void newFixedThreadPoolTest() throws Exception{
	ExecutorService executor = Executors.newFixedThreadPool(2);
	for (int i = 0; i < 6; i++) {
		final int index = i+1;
		System.out.println("task:"+(i+1));
		Runnable run = new Runnable() {
			@Override
			public void run() {
				System.out.println("thread start " + index);
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("thread end "+ index);
			}
		};
		executor.execute(run);
	}
	
	//Thread.sleep(7000);
	//当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务,否则将会抛出RejectedExecutionException异常。
	//但是,此时线程池不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。 与它相似的还有一个shutdownNow(),它通过调用Thread.interrupt来实现线程的立即退出
	executor.shutdown();
	//awaitTermination阻塞当前线程,等待剩余任务执行完,然后继续往下执行。如果不适用await,那么shutdown之后,很可能导致剩余任务得不到执行(整个程序退出),或是执行出现异常
	executor.awaitTermination(7000, TimeUnit.MILLISECONDS);
	System.err.println("完成线程!");
	
}

public static void newCachedThreadPoolTest() throws Exception{
	//如果超过60s没有新的任务线程自己退出
	ExecutorService executorService = Executors.newCachedThreadPool();
	for (int i = 0; i < 6; i++) {
		final int index = i+1;
		Runnable run = new Runnable() {
			
			@Override
			public void run() {
				System.out.println("cached线程池线程start"+index);
				try {
					Thread.sleep(1500);
					System.out.println("cached 线程结束end"+index);
				} catch (Exception e) {
					e.printStackTrace();
				}
				
			}
		};	
		executorService.execute(run);
	}
	//如果 不写这个默认60s关闭线程池线程自动关闭
	//executorService.shutdown();
}
public static void newSingleThreadExecutorTest() throws Exception{
	ExecutorService executorService = Executors.newSingleThreadExecutor();
	for (int i = 0; i < 6; i++) {
		final int index = i+1;
		Runnable run =new Runnable() {
			
			@Override
			public void run() {
				System.out.println("SingleThread线程池线程start"+index);
				try {
					Thread.sleep(1500);
					System.out.println("SingleThread 线程结束end"+index);
				} catch (Exception e) {
					e.printStackTrace();
				}					
			}
		};
		executorService.execute(run);
	}
	executorService.shutdown();
}
public static void newScheduledThreadPoolTest() throws Exception{
	ScheduledExecutorService serExecutorService = Executors.newScheduledThreadPool(10);
	int index = 1;
	Runnable run = new Runnable() {			
		@Override
		public void run() {
			System.out.println("scheduled线程Start");
			try {
				Thread.sleep(1500);
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}
	};
	serExecutorService.execute(run);
	//从上面程序运行隔8秒开始执行,没过3秒执行一次
	serExecutorService.scheduleWithFixedDelay(run, 8, 3,TimeUnit.SECONDS);
}
}











  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值