线程池

ScheduledExecutorService exec = Executors.newScheduledThreadPool(10);
		
		exec.schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println("delay 5 second!");
			}
		}, 5, TimeUnit.SECONDS);
		
		exec.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				System.out.println("init 1 delay 5");
			}
		}, 1, 5, TimeUnit.SECONDS);
		
		exec.scheduleWithFixedDelay(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("init 2 delay 7");
			}
		}, 2, 5, TimeUnit.SECONDS);

 1.Executor框架

public class ExecutorTest {
	public static void main(String[] args) {
		Executor exe = Executors.newFixedThreadPool(10);
		
		for (int i = 1; i <= 20; i++) {
			final int k = i;
			Runnable run = new Runnable() {
				@Override
				public void run() {
					System.out.println(k);
				}
			};
			exe.execute(run);
		}
	}
}

 

线程池：

newFixedThreadPool:          固定长度的线程池

newCachedThreadPool:      可缓存的线程池（回收空闲线程，增加新线程）

newSingleThreadExecutor:  保证只有一个线程工作

newScheduledThreadPool:  固定长度的线程池，并且可以延迟或定时的执行任务

 

2.ExecutorService

状态： 运行、关闭、已终止

 

private ExecutorService es = Executors.newFixedThreadPool(10);
public void start() {
		int i = 0;
		while(!es.isShutdown()) {
			i ++;
			es.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println("oo");
				}
			});
			if(i == 10) {
				stop();
			}
		}
	}
	
	public void stop() {
		es.shutdown();
	}

 

 

3.延迟任务和周期任务类 

使用ScheduledThreadPool来替代Timer,Timer执行所有的定时任务只会创建一个线程

构建自己的定时任务最好使用DelayQueue

 

ScheduledExecutorService exec = Executors.newScheduledThreadPool(10);
		
		exec.schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println("delay 5 second!");
			}
		}, 5, TimeUnit.SECONDS);
		
		exec.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				System.out.println("init 1 delay 5");
			}
		}, 1, 5, TimeUnit.SECONDS);
		
		exec.scheduleWithFixedDelay(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("init 2 delay 7");
			}
		}, 2, 5, TimeUnit.SECONDS);

 

4.携带结果Callable和Future

FutureTask对Future进行了封装

future = executor.submit(callable);

future.get()

future.cancell(true);

future.isCancelled()

future.isDone()

 

5.CompletionService

将已完成的结果保存在BlockingQueue中，结果完成时被封装成Future

package com.sosop.nio.buffer;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorTest {
	public static void main(String[] args) throws InterruptedException {
		ExecutorService exec = Executors.newFixedThreadPool(10);
		ExecutorCompletionService<Integer> completion = new ExecutorCompletionService<>(
				exec);

		for (int i = 0; i < 20; i++) {
			completion.submit(new Worker(i, i+1));
		}

		try {
			for (int i = 0; i < 20; i++) {
				Future<Integer> f = completion.take();
				int result = f.get();
				System.out.println(result);
			}
		} catch (ExecutionException e) {
			e.printStackTrace();
		} finally {
			exec.shutdown();
		}
	}
}

class Worker implements Callable<Integer> {

	private int num1;
	private int num2;

	public Worker(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}

	@Override
	public Integer call() throws Exception {
		return num1 + num2;
	}

}