线程池的使用

个人笔记  常用的四种线程池

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 生成一个有5个线程的线程池   提交20个任务  看5个线程中的哪个线程来处理任务
 * @author zhangkun
 *
 */
public class MyClass8 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
	//新建一个5个线程的线程池
	ExecutorService threadPool = Executors.newFixedThreadPool(5);
	
	Future<Integer> result = null;
	try {
		for (int i = 0; i < 20; i++) {
			//给线程池提交任务，看那个线程会对其进行处理
			result = threadPool.submit(new Callable<Integer>() {
				@Override
				public Integer call() throws Exception {
					System.out.print(Thread.currentThread().getName()+"-------");
					return new Random().nextInt(50);
				}
			});
			System.out.println(result.get()+"---"+ i);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		//关闭线程池
		threadPool.shutdown();
	}
}
}

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 单线程的线程池
 * @author Administrator
 *
 */
public class MyClass9 {
	public static void main(String[] args) {
		//新建一个只有一个线程的线程池
		ExecutorService threadPool = Executors.newSingleThreadExecutor(	);
		
		Future<Integer> result = null;
		try {
			for (int i = 0; i < 20; i++) {
				//给线程池提交任务，看那个线程会对其进行处理  这次线程池中只有一个线程
				result = threadPool.submit(new Callable<Integer>() {
					@Override
					public Integer call() throws Exception {
						System.out.print(Thread.currentThread().getName()+"-------");
						return new Random().nextInt(50);
					}
				});
				System.out.println(result.get()+"---"+ i);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//关闭线程池
			threadPool.shutdown();
		}	
	}
}

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 新建一个没有固定数量个线程的线程池   会根据往此线程池提交的任务数量，动态生成线程的个数，  当现有线程忙不过来就会在线程池中再生成一个线程
 * @author Administrator
 *
 */
public class MyClass10 {
	public static void main(String[] args) {
		//新建一个没有固定数量个线程的线程池   会根据往此线程池提交的任务数量，动态生成线程的个数，  当现有线程忙不过来就会在线程池中再生成一个线程
		ExecutorService threadPool = Executors.newCachedThreadPool();
		
		Future<Integer> result = null;
		try {
			for (int i = 0; i < 20; i++) {
				//给线程池提交任务，看那个线程会对其进行处理
				result = threadPool.submit(new Callable<Integer>() {
					@Override
					public Integer call() throws Exception {
						Thread.sleep(3000);
						System.out.print(Thread.currentThread().getName()+"-------");
						return new Random().nextInt(50);
					}
				});
				System.out.println(result.get()+"---"+ i);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//关闭线程池
			threadPool.shutdown();
		}
	}
}

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 该代码可以让线程在指定的延时之后执行
 * @author ZhangKun
 *
 */
public class MyClass11 {
	public static void main(String[] args) {
		//新建一个5个线程的线程池
		ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
		
		Future<Integer> result = null;
		try {
			for (int i = 0; i < 20; i++) {
				//给线程池提交任务，看那个线程会对其进行处理
				/** 方法api    创建并执行在给定延迟后启用的 ScheduledFuture。
				 * 第一个参数     New一个callable匿名内部类
				 * 第二个参数    时间长度
				 * 第三个参数   时间长度的单位（枚举变量） 天，小时，分钟，等
				 */
				result = threadPool.schedule(new Callable<Integer>() {
					@Override
					public Integer call() throws Exception {
						System.out.print(Thread.currentThread().getName()+"-------");
						return new Random().nextInt(50);
					}
				}, 3, TimeUnit.SECONDS);

				System.out.println(result.get()+"---");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//关闭线程池
			threadPool.shutdown();
		}
	}
}