Java网络编程精解之ServerSocket用…

package multithread4;

import java.io.*;

import java.net.*;

import java.util.concurrent.*;

public class EchoServer {

private int port=8000;

private ServerSocket serverSocket;

private ExecutorService executorService;     //线程池

private final int POOL_SIZE=4;       //单个CPU时线程池中工作线程的数目

private int portForShutdown=8001;      //用于监听关闭服务器命令的

端口

private ServerSocket serverSocketForShutdown;

private boolean isShutdown=false;     //服务器是否已经关闭

private Thread shutdownThread=new Thread(){     //负责关闭服务器的线程

public void start(){

this.setDaemon(true);       //设置为守护线程（

也称为后台线程）

super.start(); 

}

public void run(){

while (!isShutdown) {

Socket socketForShutdown=null;

try {

socketForShutdown= serverSocketForShutdown.accept();

BufferedReader br = new BufferedReader(

new InputStreamReader(socketForShutdown.getInputStream()));

String command=br.readLine();

if(command.equals("shutdown")){

long beginTime=System.currentTimeMillis(); 

socketForShutdown.getOutputStream().write("服务器正在关闭\r\n".getBytes());

isShutdown=true;

//请求关闭线程池

//线程池不再接收新的任务，但是会继续执行完工作队列中现有的任务

executorService.shutdown();  

//等待关闭线程池，每次等待的超时时间为30秒

while(!executorService.isTerminated())

executorService.awaitTermination(30,TimeUnit.SECONDS); 

serverSocket.close(); //关闭与EchoClient客户通信的ServerSocket 

long endTime=System.currentTimeMillis(); 

socketForShutdown.getOutputStream().write(("服务器已经关闭，"+

"关闭服务器用了"+(endTime-beginTime)+"毫秒\r\n").getBytes());

socketForShutdown.close();

serverSocketForShutdown.close();

}else{

socketForShutdown.getOutputStream().write("错误的命令\r\n".getBytes());

socketForShutdown.close();

}  

}catch (Exception e) {

e.printStackTrace();

} 

} 

}

};

public EchoServer() throws IOException {

serverSocket = new ServerSocket(port);

serverSocket.setSoTimeout(60000);    //设定等待客户连接的超过时间为60秒

serverSocketForShutdown = new ServerSocket(portForShutdown);

//创建线程池

executorService= Executors.newFixedThreadPool( 

Runtime.getRuntime().availableProcessors() * POOL_SIZE);

shutdownThread.start();     //启动负责关闭服务器的线程

System.out.println("服务器启动");

}

public void service() {

while (!isShutdown) {

Socket socket=null;

try {

socket = serverSocket.accept();

//可能会抛出SocketTimeoutException和SocketException

socket.setSoTimeout(60000);     //把等待客户发送数据的超时时间设为60秒 

executorService.execute(new Handler(socket));

//可能会抛出RejectedExecutionException

}catch(SocketTimeoutException e){

//不必处理等待客户连接时出现的超时异常

}catch(RejectedExecutionException e){

try{

if(socket!=null)socket.close();

}catch(IOException x){}

return;

}catch(SocketException e) {

//如果是由于在执行serverSocket.accept()方法时，

//ServerSocket被ShutdownThread线程关闭而导致的异常，就退出service()方法

if(e.getMessage().indexOf("socket closed")!=-1)return;

}catch(IOException e) {

e.printStackTrace();

}

}

}

public static void main(String args[])throws IOException {

new EchoServer().service();

}

}

class Handler implements Runnable{…}

while(!executorService.isTerminated())

executorService.awaitTermination(30,TimeUnit.SECONDS);  //等待30秒

package multithread4;

import java.net.*;

import java.io.*;

public class AdminClient{

public static void main(String args[]){

Socket socket=null;

try{

socket=new Socket("localhost",8001);

//发送关闭命令

OutputStream socketOut=socket.getOutputStream();

socketOut.write("shutdown\r\n".getBytes());

//接收服务器的反馈

BufferedReader br = new BufferedReader(

new InputStreamReader(socket.getInputStream()));

String msg=null;

while((msg=br.readLine())!=null)

System.out.println(msg);

}catch(IOException e){

e.printStackTrace();

}finally{

try{

if(socket!=null)socket.close();

}catch(IOException e){e.printStackTrace();}

}

}

}

服务器正在关闭

服务器已经关闭，关闭服务器用了60毫秒