JAVA多线程编程实践

1.Executor框架

   Executor只是个简单的接口，但它却为一个灵活而且强大的框架创造了基础，这个框架可异步执行，支持不同类型的任务执行策略。

 

public interface Executor {
    void execute(Runnable command);
}

 

2.创建线程池

   通过Executors中的某个静态工厂方法来创建一个线程池：

   newFixedThreadPool:创建一个定长的线程池，每提交一个任务创建一个线程，直道到达池的最大长度。

   

   newCachedThreadPool:创建一个可缓存的线程池，如果当前线程池的长度超过处理需求时，它可灵活的回收空闲线程，当需要增加时，可灵活的添加新线程，而不会对池的长度做任何的限制。

   

   newSingleThreadExecutor:创建一个单线程划的executor，它创建唯一的工作者线程来执行任务，如果线程异常结束，将会有另外一个来取代他。

   

   newScheduledThreadPool:创建一个定长的线程池，支持定时的以及周期性的任务执行。

 

3.ExecutorService

   ExecutorService扩展了Executor且添加了用户生命周期（运行，关闭，终止）的方法。

   Shutdown():启动一个平缓的关闭过程：停止接收新的任务，同时等待已经提交的任务完成，包括尚未开始执行的任务。

  ShutdownNow():启动一个强制的关闭过程：尝试取消所有运行中的任务与排队在队列中尚未开始的任务。

终止：可调用awaitTermination(long timeout,TimeUnit unit) 等待ExecutorService达到终止状态，也可以用i isTerminated来判断ExecutorService是否已近终止。通常shutdown会紧随awaitTermination之后，这样可以同步的关闭ExecutorService的效果。

 

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

public class Test {
	public static void main(String[] args) {
		ExecutorService service1 = Executors.newCachedThreadPool();
		for(int i = 1; i < 4; i++){
			service1.execute(new Task(i));
		}
		service1.shutdown();
//		ExecutorService service2 = Executors.newFixedThreadPool(2);
//		for(int i = 1; i < 4; i++){
//			service2.execute(new Task(i));
//		}
//		service2.shutdown();
//		ExecutorService service3 = Executors.newSingleThreadExecutor();
//		for(int i = 1; i < 4; i++){
//			service3.execute(new Task(i));
//		}
//		service3.shutdown();
	}
}

class Task implements Runnable{
	private int i;
	
	public Task(int i) {
		this.i = i;
	}

	@Override
	public void run() {
		try {
			Thread.sleep(1000);
			System.out.println("current thread " + i + " is running");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

 

4.CompletionService:

   CompletionService整合了Executor和BlockingQueue的功能。你可以将callable任务提交给他执行，然后类似队列的take和poll方法，在结果完整可用时获取结果。CompletionService的实现是维护一个保存Future对象的BlockingQueue。

    poll:非阻塞，若目前无结果，返回null。

    take：阻塞，若当前无结果，则阻塞至返回结果。

 

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
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 CompletionTask {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		for(int i = 1; i <= 100; i++){
			list.add(i);
		}
		ExecutorService service = Executors.newCachedThreadPool();
		CompletionService<Integer> com = new ExecutorCompletionService<>(service);

		List<Integer> numbers = new ArrayList<>();
		for(int i = 1; i <= 100; i++){
			if(i % 10 == 0){
				com.submit(new Task(numbers));
				numbers = new ArrayList<>();
				numbers.add(i);
			}else{
				numbers.add(i);
			}
		}
		service.shutdown();
		int result = 0;
		try {
			for(int i=0;i<10;i++){
				Future<Integer> future = com.take();
				int res = future.get();
				result = result + res;
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("执行结果为："+result);
	}
}

class Task implements Callable<Integer>{

	private List<Integer> numbers;

	public Task(List<Integer> numbers) {
		this.numbers = numbers;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(Integer num : numbers){
			sum = sum + num;
		}
		return sum;
	}
}

 当然执行结果为4950