Java 5.0 多线程编程实践(2)

　　服务器端的完整实现

　　服务器端的完整实现代码如下：

　　package com.andrew;

　　import java.io.DataOutputStream;
　　import java.io.IOException;
　　import java.io.Serializable;
　　import java.net.ServerSocket;
　　import java.net.Socket;
　　import java.util.concurrent.ArrayBlockingQueue;
　　import java.util.concurrent.BlockingQueue;
　　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;
　　import java.util.concurrent.RejectedExecutionHandler;
　　import java.util.concurrent.ThreadPoolExecutor;
　　import java.util.concurrent.TimeUnit;
　　import java.util.concurrent.locks.ReentrantLock;

　　public class Server {
　　private static int produceTaskSleepTime = 100;
　　private static int consumeTaskSleepTime = 1200;
　　private static int produceTaskMaxNumber = 100;
　　private static final int CORE_POOL_SIZE = 2;
　　private static final int MAX_POOL_SIZE = 100;
　　private static final int KEEPALIVE_TIME = 3;
　　private static final int QUEUE_CAPACITY = (CORE_POOL_SIZE + MAX_POOL_SIZE) / 2;
　　private static final TimeUnit TIME_UNIT = TimeUnit.SECONDS;
　　private static final String HOST = "127.0.0.1";
　　private static final int PORT = 19527;
　　private BlockingQueue workQueue = new ArrayBlockingQueue(QUEUE_CAPACITY);
　　//private ThreadPoolExecutor serverThreadPool = null;
　　private ExecutorService pool = null;
　　private RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.DiscardOldestPolicy();
　　private ServerSocket serverListenSocket = null;
　　private int times = 5;
　　public void start() {
　　// You can also init thread pool in this way.
　　/*serverThreadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
　　MAX_POOL_SIZE, KEEPALIVE_TIME, TIME_UNIT, workQueue,
　　rejectedExecutionHandler);*/
　　pool = Executors.newFixedThreadPool(10);
　　try {
　　　serverListenSocket = new ServerSocket(PORT);
　　　serverListenSocket.setReuseAddress(true);

　　　System.out.println("I'm listening");
　　　while (times-- > 0) {
　　　　Socket socket = serverListenSocket.accept();
　　　　String welcomeString = "hello";
　　　　//serverThreadPool.execute(new ServiceThread(socket, welcomeString));
　　　　pool.execute(new ServiceThread(socket));
　　　}
　　} catch (IOException e) {
　　　// TODO Auto-generated catch block
　　　e.printStackTrace();
　　}
　　cleanup();
　　}

　　public void cleanup() {
　　if (null != serverListenSocket) {
　　　try {
　　　　serverListenSocket.close();
　　　} catch (IOException e) {
　　　　// TODO Auto-generated catch block
　　　　e.printStackTrace();
　　　}
　　}
　　//serverThreadPool.shutdown();
　　pool.shutdown();
　　}

　　public static void main(String args[]) {
　　Server server = new Server();
　　server.start();
　　}
　　}

　　class ServiceThread implements Runnable, Serializable {
　　private static final long serialVersionUID = 0;
　　private Socket connectedSocket = null;
　　private String helloString = null;
　　private static int count = 0;
　　private static ReentrantLock lock = new ReentrantLock();

　　ServiceThread(Socket socket) {
　　connectedSocket = socket;
　　}

　　public void run() {
　　increaseCount();
　　int curCount = getCount();
　　helloString = "hello, id = " + curCount + " ";

　　ExecutorService executor = Executors.newSingleThreadExecutor();
　　Future future = executor.submit(new TimeConsumingTask());

　　DataOutputStream dos = null;
　　try {
　　　dos = new DataOutputStream(connectedSocket.getOutputStream());
　　　dos.write(helloString.getBytes());
　　　try {
　　　　dos.write("let's do soemthing other. ".getBytes());
　　　　String result = future.get();
　　　　dos.write(result.getBytes());
　　　} catch (InterruptedException e) {
　　　　e.printStackTrace();
　　　} catch (ExecutionException e) {
　　　　e.printStackTrace();
　　　}
　　} catch (IOException e) {
　　　// TODO Auto-generated catch block
　　　e.printStackTrace();
　　} finally {
　　　if (null != connectedSocket) {
　　　　try {
　　　　　connectedSocket.close();
　　　　} catch (IOException e) {
　　　　　// TODO Auto-generated catch block
　　　　　e.printStackTrace();
　　　　}
　　　}
　　　if (null != dos) {
　　　　try {
　　　　　dos.close();
　　　　} catch (IOException e) {
　　　　　// TODO Auto-generated catch block
　　　　　e.printStackTrace();
　　　　}
　　　}
　　　executor.shutdown();
　　}
　　}

　　private int getCount() {
　　int ret = 0;
　　try {
　　　lock.lock();
　　　ret = count;
　　} finally {
　　　lock.unlock();
　　}
　　return ret;
　　}

　　private void increaseCount() {
　　try {
　　　lock.lock();
　　　++count;
　　} finally {
　　　lock.unlock();
　　}
　　}
　　}

　　class TimeConsumingTask implements Callable {
　　public String call() throws Exception {
　　System.out.println("It's a time-consuming task, you'd better retrieve your result in the furture");
　　return "ok, here's the result: It takes me lots of time to produce this result";
　　}

　　}