socket，线程池（TCP通信）

Server 1

package day20150914socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端应用程序
 * （MINA的本质也是使用server）
 */
public class Server {
    //服务端的Socket
    private ServerSocket server;
    //构造方法，用于初始化服务端
    public Server() throws IOException{
        try {
            System.out.println("初始化服务端");
            /*
             * 创建ServerSocket时需要指定的服务端口
             */
            server = new ServerSocket(8088);
            System.out.println("服务端初始化完毕");
        } catch (IOException e) {
            throw e;
        }
    }

    public void start(){
        try {
            System.out.println("等待客户端连接。。。");
            /*
             * ServerSocket的accept()方法：
             * 用于监听8088端口，等待客户连接， 否则该方法阻塞。
             * 若一个客户端连接了，会返回给客户端的Socket
             */
            Socket socket = server.accept();
            //获取远端（客户端）地址
            InetAddress address = socket.getInetAddress();
            //获取远端IP地址
            String ip = address.getHostAddress();
            //获取远端端口号
            int port = socket.getPort();
            System.out.println(ip+":"+port+"客户端连接上了");
            /*
             * 通过刚刚连接上来的客户端的Socket获取输入流
             * 来读取客户端发过来的信息
             */
            InputStream in = socket.getInputStream();
            //将字节输入流包装为字符输入流，这样就可指定编码集
            InputStreamReader isr = new InputStreamReader(in,"utf-8");
            //将字符流转为缓冲字符输入流，这样就可以以行为单位来读取字符串了
            BufferedReader br = new BufferedReader(isr);
            String message = null;
            while((message=br.readLine())!=null){
                System.out.println("客户端说："+message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        try {
            Server server = new Server();
            server.start();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器初始化失败");
        }

    }

}

Client 1

package day20150914socket;

import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    //用于连接服务器端的Socket
    private Socket socket;

    public Client() throws Exception{
        try {
            System.out.println("正在连接服务端。。。");
            /*
             * 创建Socket对象，
             * 就会尝试根据给定的地址与端口连接服务器
             * 所以，若该对象创建成功，说明与服务器端连接正常
             */
            //localhost:本机。连接其他计算机可写IP
            socket = new Socket("localhost",8088);
            System.out.println("成功连接服务端。");
        } catch (Exception e) {
            throw e;
        }
    }

    public void start(){
        try{
            /*
             * 可以通过Socket的getOutputStream()方法获取一条输出流
             * 用于将信息发送至服务器
             */
            OutputStream out = socket.getOutputStream();
            /*
             *使用字符流指定编码集将字符串转为字节后，
             *再通过out发送给服务器 
             */
            OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
            /*
             * 将字符流包装为缓冲字符流
             * 就可以以行为单位写出字符串了。
             */
            PrintWriter pw = new PrintWriter(osr);

            Scanner sc = new Scanner(System.in);
            while(true){
                String str = sc.nextLine();
                pw.println(str);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            Client client = new Client();
            client.start();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("客户端初始化失败");
        }
    }

}

Server(2)

package day20150914socket2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服务端应用程序
 * （MINA的本质也是使用server）
 */
public class Server2 {
    //服务端的Socket
    private ServerSocket server;
    //线程池，用于管理客户端连接的交互线程
    private ExecutorService threadPool;
    //保存所有客户端输出流的集合
    private List<PrintWriter> allOut;
    //构造方法，用于初始化服务端
    public Server2() throws IOException{
        try {
            System.out.println("初始化服务端");
            /*
             * 创建ServerSocket时需要指定的服务端口
             */
            server = new ServerSocket(8088);
            //初始化线程池
            threadPool = Executors.newFixedThreadPool(50);
            /*
             * 初始化存放所有客户端输出流的集合
             * 使用ArrayList而不是linkedList的原因：
             * 增删元素不频繁，而是使用遍历频繁
             */
            allOut = new ArrayList<PrintWriter>();
            System.out.println("服务端初始化完毕");
        } catch (IOException e) {
            throw e;
        }
    }

    public void start(){
        try {
            /*
             * ServerSocket的accept()方法：
             * 用于监听8088端口，等待客户连接， 否则该方法阻塞。
             * 若一个客户端连接了，会返回给客户端的Socket
             */
            while(true){
                System.out.println("等待客户端连接。。。");
                Socket socket = server.accept();
                /*
                 * 当一个客户端连接后，启动一个线程ClientHandler
                 * 将客户端的socket传入，使得该线程处理与该客户端的交互
                 * 这样，可再次进入循环，接收下一个客户端的连接
                 */
                Runnable handler = new ClientHandler(socket);
                //Thread t = new Thread(handler);
                //t.start();
                /*
                 * 使用线程池分配空闲线程来处理当前连接的客户端
                 */
                threadPool.execute(handler);
            }

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

    }
    /**
     * 将给定的输出流存入共享集合
     * 
     * 加synchronized关键字，锁定Server对象，
     * 下面3个方法锁定后，互斥（3个方法锁定同一个对象）
     * 即一个线程访问其中一个方法后，
     * 其他线程不可访问这3个方法中的任何一个
     */
    public synchronized void addOut(PrintWriter pw){
        allOut.add(pw);
    }
    /**
     * 将给定的输出流从共享集合中删除
     */
    public synchronized void removeOut(PrintWriter pw){
        allOut.remove(pw);
    }
    /**
     * 将给定的消息转发给所有客户端
     */
    public synchronized void sendMessage(String message){
        for(PrintWriter pw : allOut){
            pw.println(message);
        }
    }
    public static void main(String[] args) {
        try {
            Server2 server = new Server2();
            server.start();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器初始化失败");
        }

    }
    /**
     * 服务器端的一个线程，用于与某个客户端交互，
     * 使用线程的目的是使得服务器可以处理多个客户端了
     */
    class ClientHandler implements Runnable{
        //当前线程处理的客户端的socket
        private Socket socket;
        //当前客户端的IP
        private String ip;
        //当前客户端的昵称
        private String nickname;
        /**
         * 根据给定的客户端的Socket，创建线程体
         */
        public ClientHandler(Socket socket){
            this.socket = socket;
            //获取远端（客户端）地址
            InetAddress address = socket.getInetAddress();
            //获取远端IP地址
            ip = address.getHostAddress();
            //获取远端端口号
            int port = socket.getPort();
            //改为使用昵称，所以不在这里通知了
            //System.out.println(ip+":"+port+"客户端连接上了");
        }
        /**
         * 该线程会将当前socket中的输入流获取
         * 用来循环读取客户端发送过来的消息
         */
        @Override
        public void run() {
            PrintWriter pw = null;
            try{
                /*
                 * 为了让服务端向客户端发送信息
                 * 通过socket获取输出流
                 */
                OutputStream out = socket.getOutputStream();
                //转为字符流，用于指定编码集
                OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
                //创建缓冲字符输出流，true自动行刷新
                pw = new PrintWriter(osr,true);
                /*
                 * 将该客户端的输出流存入共享集合
                 * 以便使得该客户端也能接收服务器转发的消息
                 */
                //allOut.add(pw);
                addOut(pw);
                System.out.println("当前在线人数："+allOut.size());
                /*
                 * 通过刚刚连接上来的客户端的Socket获取输入流
                 * 来读取客户端发过来的信息
                 */
                InputStream in = socket.getInputStream();
                //将字节输入流包装为字符输入流，这样就可指定编码集
                InputStreamReader isr = new InputStreamReader(in,"utf-8");
                //将字符流转为缓冲字符输入流，这样就可以以行为单位来读取字符串了
                BufferedReader br = new BufferedReader(isr);
                //当创建好当前客户端的输入流后，读取的第一个字符串应当是昵称
                nickname = br.readLine();
                //通知所有客户端，当前用户上线了
                sendMessage("["+nickname+"]上线了");
                sendMessage("当前在线人数为："+allOut.size());//告知所有客户端在线人数
                String message = null;
                /*
                 * 读取客户端发来的一行字符串
                 * windows与linux的差异：
                 * linux：当客户端断开连接后，通过输入流会读取到null,
                 * 这是合乎逻辑的，
                 * 因为缓冲流的readLine方法若返回null就无法通过该流读取到信息
                 * 
                 * windows：当客户端与服务器端断开接连后
                 * readLine()方法会抛出异常
                 */
                while((message=br.readLine())!=null){
                    //System.out.println("客户端说："+message);
                    //pw.println(message);//把客户端发来的消息回给客户端
                    //当前客户端说话内容告诉给所有客户端
                    sendMessage(nickname+"说："+message);
                }
            }catch(Exception e){
                /*
                 * 在windows中的客户端
                 * 报错通常是因为客户端断开了连接
                 * 
                 * 不用关流，可直接关Socket
                 */
            }finally{
                /*
                 * 首先将该客户端的输出流从共享集合中删除
                 */
                //allOut.remove(pw);
                removeOut(pw);

                //控制台显示该用户下线了
                System.out.println("["+nickname+"]下线了");
                //通知其他用户该用户下线了
                sendMessage("["+nickname+"]下线了");

                //输出当前在线人数（输出流的个数）
                System.out.println("当前在线人数为："+allOut.size());
                sendMessage("当前在线人数为："+allOut.size());//告知所有客户端在线人数

                /*
                 * 无论是linux用户还是windows用户，
                 * 当客户与服务端断开连接后，
                 * 我们都应当在服务器端与客户端断开连接
                 */
                try {
                    socket.close();
                    //关闭之后，catch处理意义也不大，故catch块里的内容可为空
                } catch (IOException e) {
                }
                //System.out.println("一个客户端下线了");
            }
        }

    }

}

Client(2)

package day20150914socket2;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Client2 {
    //用于连接服务器端的Socket
    private Socket socket;

    public Client2() throws Exception{
        try {
            System.out.println("正在连接服务端。。。");
            /*
             * 创建Socket对象，
             * 就会尝试根据给定的地址与端口连接服务器
             * 所以，若该对象创建成功，说明与服务器端连接正常
             */
            //localhost:本机。连接其他计算机可写IP
            socket = new Socket("localhost",8088);
            System.out.println("成功连接服务端。");
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     * 客户端启动方法
     */
    public void start(){
        try{
            //创建并启动线程，来接收服务器端发送过来的消息
            Runnable runn = new GetServerInfoHandler();
            Thread t = new Thread(runn);
            t.start();
            /*
             * 可以通过Socket的getOutputStream()方法获取一条输出流
             * 用于将信息发送至服务器
             */
            OutputStream out = socket.getOutputStream();
            /*
             *使用字符流指定编码集将字符串转为字节后，
             *再通过out发送给服务器 
             */
            OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
            /*
             * 将字符流包装为缓冲字符流
             * 就可以以行为单位写出字符串了。
             */
            PrintWriter pw = new PrintWriter(osr,true);//true，自动行刷新
            //创建一个Scanner,用于接收用户输入的字符串
            Scanner sc = new Scanner(System.in);
            //输出欢迎语
            System.out.println("欢迎来到传奇的聊天室");
            while(true){
                System.out.println("请输入昵称");
                String nickname = sc.nextLine();
                if(nickname.trim().length()>0){
                    pw.println(nickname);
                    break;
                }
                System.out.println("昵称不能为空");
            }
            while(true){
                String str = sc.nextLine();
                pw.println(str);
                //pw.flush();//PrintWriter自动行刷新就不要此句了
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            Client2 client = new Client2();
            client.start();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("客户端初始化失败");
        }
    }
    /**
     * 该线程的作用是循环接收服务器端发送过来的信息，
     * 并输出到控制台
     */
    class GetServerInfoHandler implements Runnable{

        @Override
        public void run() {
            try{
                //通过socket获取输入流
                InputStream in = socket.getInputStream();
                //将字节输入流转为字符输入流，指定编码集
                InputStreamReader isr = new InputStreamReader(in,"utf-8");
                //将字符流转为缓冲字符输入流，这样就可以以行为单位来读取字符串了
                BufferedReader br = new BufferedReader(isr);
                String message = null;
                //循环读取服务端发送过来的每个字符串
                while((message=br.readLine())!=null){
                    //将服务端发送的字符串输出到控制台
                    System.out.println(message);
                }
            }catch(Exception e){

            }
        }
    }
}