阻塞通信之Socket编程

 1     public void service(){
 2         while (true) {
 3             Socket socket = null;
 4             try {
 5                 socket = serverSocket.accept();
 6                 System.out.println("new connection accepted " + socket.getInetAddress() + ":" + socket.getPort());
 7                 BufferedReader br = getBufferReader(socket);//获得socket输入流,并将之包装成BufferedReader
 8                 PrintWriter pw = getWriter(socket);//获得socket输出流,并将之包装成PrintWriter
 9                 String msg = null;
10                 while ((msg = br.readLine()) != null) {
11                     
12                     pw.println(echo(msg));//服务端的处理逻辑,将client发来的数据原封不动再发给client
13                     pw.flush();
14                     if(msg.equals("bye"))//若client发送的是 "bye" 则关闭socket
15                         break;
16                 }
17             } catch (IOException e) {
18                 e.printStackTrace();
19             } finally {
20                 try{
21                     if(socket != null)
22                         socket.close();
23                 }catch(IOException e){e.printStackTrace();}
24             }
25         }
26     }

    public ServerSocket(int port, int backlog) throws IOException {
        this(port, backlog, null);
    }

 1     public void service() {
 2         while (true) {
 3             Socket socket = null;
 4             try {
 5                 socket = serverSocket.accept();//接受client的连接请求
 6                 new Thread(new Handler(socket)).start();//每接受一个请求 就创建一个新的线程 负责处理该请求
 7             } catch (IOException e) {
 8                 e.printStackTrace();
 9             } 
10             finally {
11                 try{
12                     if(socket != null)
13                         socket.close();
14                 }catch(IOException e){e.printStackTrace();}
15             }
16         }
17     }

 1 class Handler implements Runnable{
 2     Socket socket;
 3     public Handler(Socket socket) {
 4         this.socket = socket;
 5     }
 6     
 7     @Override
 8     public void run() {
 9         try{
10             BufferedReader br = null;
11             PrintWriter pw = null;
12             System.out.println("new connection accepted " + socket.getInetAddress() + ":" + socket.getPort());
13             
14             br = getBufferReader(socket);
15             pw = getWriter(socket);
16             
17             String msg = null;
18             while((msg = br.readLine()) != null){
19                 pw.println(echo(msg));
20                 pw.flush();
21                 if(msg.equals("bye"))
22                     break;
23             }
24         }catch(IOException e){
25             e.printStackTrace();
26         }
27     }

 1 public class EchoServerThreadPool {
 2     private int port = 8000;
 3     private ServerSocket serverSocket;
 4     private ExecutorService executorService;
 5     private static int POOL_SIZE = 4;//每个CPU中线程拥有的线程数
 6     
 7     public EchoServerThreadPool()throws IOException {
 8         serverSocket = new ServerSocket(port);
 9         executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
10         System.out.println("server start");
11     }
12     
13     public void service(){
14         while(true){
15             Socket socket = null;
16             try{
17                 socket = serverSocket.accept();//等待接受Client连接
18                 executorService.execute(new Handler(socket));//将已经建立连接的请求交给线程池处理
19             }catch(IOException e){
20                 e.printStackTrace();
21             }
22         }
23     }
24     public static void main(String[] args)throws IOException{
25         new EchoServerThreadPool().service();
26     }
27 }

       try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }

public synchronized void setSendBufferSize(int size)
    throws SocketException{
        if (!(size > 0)) {
            throw new IllegalArgumentException("negative send size");
        }
        if (isClosed())
            throw new SocketException("Socket is closed");
        getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
    }

    public void setTcpNoDelay(boolean on) throws SocketException {
        if (isClosed())
            throw new SocketException("Socket is closed");
        getImpl().setOption(SocketOptions.TCP_NODELAY, Boolean.valueOf(on));
    }

    /**
     * When the keepalive option is set for a TCP socket and no data
     * has been exchanged across the socket in either direction for
     * 2 hours (NOTE: the actual value is implementation dependent),
     * TCP automatically sends a keepalive probe to the peer. This probe is a
     * TCP segment to which the peer must respond.
     * One of three responses is expected:
     * 1. The peer responds with the expected ACK. The application is not
     *    notified (since everything is OK). TCP will send another probe
     *    following another 2 hours of inactivity.
     * 2. The peer responds with an RST, which tells the local TCP that
     *    the peer host has crashed and rebooted. The socket is closed.
     * 3. There is no response from the peer. The socket is closed.
     *
     * The purpose of this option is to detect if the peer host crashes.
     *
     * Valid only for TCP socket: SocketImpl

    /**
     * Specify a linger-on-close timeout.  This option disables/enables
     * immediate return from a <B>close()</B> of a TCP Socket.  Enabling
     * this option with a non-zero Integer <I>timeout</I> means that a
     * <B>close()</B> will block pending the transmission and acknowledgement
     * of all data written to the peer, at which point the socket is closed
     * <I>gracefully</I>.  Upon reaching the linger timeout, the socket is
     * closed <I>forcefully</I>, with a TCP RST. Enabling the option with a
     * timeout of zero does a forceful close immediately. If the specified
     * timeout value exceeds 65,535 it will be reduced to 65,535.
     * <P>
     * Valid only for TCP: SocketImpl
     *
     * @see Socket#setSoLinger
     * @see Socket#getSoLinger
     */
    public final static int SO_LINGER = 0x0080;