Java线程池以及执行器的使用

//显式创建线程
new Thread(new RunnableTask()).start();

//使用Executor, 解耦创建对象和线程运行机制
Executor executor = new anExecutor();
executor.executor(new RunnableTask());

public class DirectExecutor implements Executor
{
	public void executor(Runnable task)
	{
		task.run();
	}
}

public class ThreadPerTaskExecutor implements Executor
{
	public void executor(Runnable task)
	{
		new Thread(task).start();
	}
}

public SerialExecutor implements Executor
{
	//保存提交上来的任务, 但在保存前需要对任务进行包装.
	final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
	//最终执行任务的执行器.
	final Executor executor;
	//当前需要执行的任务.
	Runnable active;

	public SerialExecutor (Executor executor)
	{
		this.executor = executor;
	}

	//该执行程序只负责将提交的任务进行再包装, 同时如果是第一次调度此执行器的话, 使任务开始执行.
	public synchronized void executor(final Runnable task)
	{
		//将提交的任务进行包装.
		tasks.offer(new Runnable(){
			public void run()
			{
				try
				{
					task.run();
				}
				finally
				{
					//在当前任务调度完成后,执行下一个任务.
					scheduleNext();
				}
			}
		});

		//第一次调度此执行器.
		if (active == null)
		{
			scheduleNext();
		}
	}

	public synchronized void scheduleNext()
	{
		while ((active = tasks.poll()) != null)
		{
			//真正执行提交来的任务, 此方法的执行不影响当前对象调用自己的executor方法来向集合中添加新的任务.
			executor.executor(active);
		}
	}
}

public NetworkService
{
	private final ServerSocket serverSocket;
	private final ExecutorService pool;

	public NetworkService(int port, int poolSize) throws IOException
	{
		serverSocket = new ServerSocket(port);
		pool = Executor.newFixedThreadPool(poolSize);
	}
	
	//run this NetworkService
	public void startServer()
	{
		try
		{
			while (true)
			{
				pool.submit(new Handler(serverSocket.accept()));
			}
		}
		finally
		{
			//如果出现异常, 需要关闭资源. 这里只对ExecutorService对象做了详细的处理.
			shutdownResource();
		}
	}

	private void shutdownResource()
	{
		try
		{
			pool.shutdown();
			serverSocket.close();
			
			//Wait a while for existing tasks to terminate.
			if (!pool.awaitTermintion(60, TimeUnit.SECONDS))
			{
				pool.shutdownNow();
				//Wait a while for tasks to respond to being cancelled			if (!pool.awaitTermintion(60, TimeUnit.SECONDS))
					System.err.println("Pool did not terminate");
			}

		}
		catch (Exception e)
		{
			// (Re-)Cancel if current thread also interrupted
			pool.shutdownNow();
			// Preserve interrupt status
			Thread.currentThread().interrupt();
		}
	}
}

class Handler implements Runnable
{
	private final Socket socket;

	public Handler(Socket socket)
	{
		this.socket = socket;
	}

	public void run()
	{
		//do something about this socket.
	}
}

class BeeperControl
{
	private final ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(1);

	public void beepForAnHour()
	{
		final Runnable beeper = new Runnable(
			public void run()
			{
				System.out.println("beep");
			}
		);

		//将每10秒蜂鸣一次的任务交给scheduled.
		final ScheduledFuture<?> beeperHandler = scheduled.scheduleAtFixedRate(beeper, 10, 10, TimeUnit.SECONDS);

		//在一小时后结束蜂鸣任务.
		scheduled.schedule(new Runnable{
			public void run()
			{
				beeperHandler.cancel(ture);
			}
		}, 60*60, TimeUnit.SECONDS);
	}
}