线程池系列三：结合线程池实现Socket

from :
http://zy116494718.iteye.com/blog/1725689



Java5增加了新的类库并发集java.util.concurrent，该类库为并发程序提供了丰富的API多线程编程在Java 5中更加容易，灵活。本文通过一个网络服务器模型，来实践Java5的多线程编程，该模型中使用了Java5中的线程池，阻塞队列，可重入锁等，还实践了 Callable， Future等接口，并使用了Java 5的另外一个新特性泛型。

　一、简介

　　本文将实现一个网络服务器模型，一旦有客户端连接到该服务器，则启动一个新线程为该连接服务，服务内容为往客户端输送一些字符信息。一个典型的网络服务器模型如下：

　　1. 建立监听端口。

　　2. 发现有新连接，接受连接，启动线程，执行服务线程。 3. 服务完毕，关闭线程。

　　这个模型在大部分情况下运行良好，但是需要频繁的处理用户请求而每次请求需要的服务又是简短的时候，系统会将大量的时间花费在线程的创建销 毁。Java 5的线程池克服了这些缺点。通过对重用线程来执行多个任务，避免了频繁线程的创建与销毁开销，使得服务器的性能方面得到很大提高。因此，本文的网络服务器 模型将如下：

　　1. 建立监听端口，创建线程池。

　　2. 发现有新连接，使用线程池来执行服务任务。

　　3. 服务完毕，释放线程到线程池。

　　下面详细介绍如何使用Java 5的concurrent包提供的API来实现该服务器。

　　初始化

　　初始化包括创建线程池以及初始化监听端口。创建线程池可以通过调用java.util.concurrent.Executors类里的静态 方法newChahedThreadPool或是newFixedThreadPool来创建，也可以通过新建一个 java.util.concurrent.ThreadPoolExecutor实例来执行任务。这里我们采用newFixedThreadPool方 法来建立线程池。

ExecutorService pool = Executors.newFixedThreadPool(10);

　　表示新建了一个线程池，线程池里面有10个线程为任务队列服务。

　　使用ServerSocket对象来初始化监听端口。

private static final int PORT = 19527;
serverListenSocket = new ServerSocket(PORT);
serverListenSocket.setReuseAddress(true);
serverListenSocket.setReuseAddress(true);

　　服务新连接

　　当有新连接建立时，accept返回时，将服务任务提交给线程池执行。

while(true){
　Socket socket = serverListenSocket.accept();
　pool.execute(new ServiceThread(socket));
}

　　这里使用线程池对象来执行线程，减少了每次线程创建和销毁的开销。任务执行完毕，线程释放到线程池。

　　服务任务

　　服务线程ServiceThread维护一个count来记录服务线程被调用的次数。每当服务任务被调用一次时，count的值自增1，因此 ServiceThread提供一个increaseCount和getCount的方法，分别将count值自增1和取得该count值。由于可能多个 线程存在竞争，同时访问count，因此需要加锁机制，在Java 5之前，我们只能使用synchronized来锁定。Java 5中引入了性能更加粒度更细的重入锁ReentrantLock。我们使用ReentrantLock保证代码线程安全。下面是具体代码：

private static ReentrantLock lock = new ReentrantLock ();
private static int count = 0;
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();
　}
}



二、服务器端的完整实现

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

Java代码  收藏代码
package demo; 
 
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(); 
       //调用 shutdown() 方法之后，主线程就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法，那么线程池会一直保持下去，以便随时添加新的任务。interrupt():只有阻塞（sleep,wait,join的线程调用他们的interrupt()才起作用，正在运行的线程不起作用也不抛异常） 
    } 
 
    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 + "\r\n"; 
 
        ExecutorService executor = Executors.newSingleThreadExecutor(); 
        Future<String> 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.\r\n".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<String> 
{ 
    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"; 
    } 
 
} 

ps:
这里重点介绍下Future 和 Callable。Callable接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable不会返回结果，并且无法抛出经过检查的异常。Callable可以和Future配合使用，用Future的get方法可以取得Callable中返回的值。

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new TimeConsumingTask());
dos.write("let's do soemthing other.\r\n".getBytes());
String result = future.get();
dos.write(result.getBytes());

使用ExecutorService的submit方法提交一个Callable的任务，返回一个Future接口的引用。这种做法对费时的任务非常有效，submit任务之后可以继续执行下面的代码，然后在适当的位置可以使用Future的get方法来获取结果，如果这时候该方法已经执行完毕，则无需等待即可获得结果，如果还在执行，get会阻塞直到它完成。

如上所示，在new TimeConsumingTask()后线程不会阻塞，而是在submit任务后继续执行dos.write().... 等操作，
然后再想取得结果的时候用future.get()方法取得。

其中TimeConsumingTask实现了Callable接口
Java代码  收藏代码
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"; 
} 
}  


这里使用了Java 5的另外一个新特性泛型，声明TimeConsumingTask的时候使用了String做为类型参数。必须实现Callable接口的call函数，其作用类似于Runnable中的run函数，在call函数里写入要执行的代码，其返回值类型等同于在类声明中传入的类型值。

Fature实现了3个功能：1.获取任务的结果2.取消任务3.获得任务进行状态（完成还是被取消）。

方法介绍：
boolean cancel(boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束
boolean isCancelled() 任务是否已经取消，任务正常完成前将其取消，则返回 true
boolean isDone() 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true
V  get() throws InterruptedException, ExecutionException  等待任务执行结束，然后获得V类型的结果。
             InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，
             还会抛出CancellationException V     
get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同
上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException