Java Socket实现基于TCP多线程通信

1 TCP简介

TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能，用户数据报协议（UDP，下一篇博客会实现）是同一层内 另一个重要的传输协议。在因特网协议族（Internet protocol suite）中，TCP层是位于IP层之上，应用层之下的中间层。不同主机的应用层之间经常需要可靠的、像管道一样的连接，但是IP层不提供这样的流机制，而是提供不可靠的包交换。
应用层向TCP层发送用于网间传输的、用8位字节表示的数据流，然后TCP把数据流分区成适当长度的报文段（通常受该计算机连接的网络的数据链路层的最大传输单元（ MTU）的限制）。之后TCP把结果包传给IP层，由它来通过网络将包传送给接收端实体的TCP层。TCP为了保证不发生丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的包发回一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未收到确认，那么对应的数据包就被假设为已丢失将会被进行重传。TCP用一个校验和函数来检验数据是否有错误；在发送和接收时都要计算校验和。
基于TCP协议实现网络通信的类有客户端的Socket类和服务器端的ServerSocket类。

2 通过Socket实现TCP编程

2.1 服务器端套路

(1)创建ServerSocket对象，绑定监听端口。
(2)通过accept()方法监听客户端请求。
(3)连接建立后，通过输入流读取客户端发送的请求信息。
(4)通过输出流向客户端发送响应信息。
(5)关闭响应的资源。

2.2 客户端套路

(1)创建Socket对象，指明需要连接的服务器的地址和端口号。
(2)连接建立后，通过输出流向服务器发送请求信息。
(3)通过输入流获取服务器响应的信息。
(4)关闭相应资源。

2.3 多线程实现服务器与多客户端之间通信步骤

(1)服务器端创建ServerSocket，循环调用accept()等待客户端连接。
(2)客户端创建一个socket并请求和服务器端连接。
(3)服务器端接受客户端请求，创建socket与该客户建立专线连接。
(4)建立连接的两个socket在一个单独的线程上对话。
(5)服务器端继续等待新的连接。

3 代码实现

（1）创建处理线程类
ServerThread这里选择实现runnable接口而不是继承Thread是因为一个类只能继承一个父类，当我需要继承其他类的时，父类就就不好处理了。

package com.socket.test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class ServerThread implements Runnable{

    Socket socket = null;//和本线程相关的Socket
    public ServerThread(Socket socket) {
    this.socket = socket;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        OutputStream os = null;
        PrintWriter pw = null;
        try {
            //与客户端建立通信，获取输入流，读取取客户端提供的信息
            is = socket.getInputStream();
            isr = new InputStreamReader(is,"UTF-8");
            br = new BufferedReader(isr);
            String data = null;
            while((data=br.readLine()) != null){//循环读取客户端的信息
                System.out.println("我是服务器，客户端提交信息为："+data);
            }
            socket.shutdownInput();//关闭输入流

            //获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("服务器端响应成功！");
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源即相关socket
            try {
                if(pw!=null)
                    pw.close();
                if(os!=null)
                    os.close();
                if(br!=null)
                    br.close();
                if(isr!=null)
                    isr.close();
                if(is!=null)
                    is.close();
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

（2）创建服务器端类
使用while以达到可以循环侦听不同客户端的连接请求。因为这是一个死循环，所以不用关闭也没有机会去关闭serverSocket。设置count值，用于记录服务器端被连接过的次数并显示客户端所在ip值。如果线程处理类是继承Thread类，那么创建新线程代码可以改为ServerThread serverThread = new ServerThread(socket);serverThread.start();

package com.socket.test;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    public static void main(String[] args) {
        try{
            //创建一个服务器端的Socket，即ServerSocket，绑定需要监听的端口
            ServerSocket serverSocket = new ServerSocket(8089);
            Socket socket = null;
            //记录连接过服务器端的数量
            int count=0;
            System.out.println("***服务器即将启动，等待客户端的连接***");
            while(true){//循环侦听新的客户端的连接
                //调用accept()方法侦听，等待客户端的连接以获取Socket实例
                socket = serverSocket.accept();
                //创建新线程
                Thread thread = new Thread(new ServerThread(socket));
                thread.start();

                count++;
                System.out.println("服务器端被连接过的次数："+count);
                InetAddress address = socket.getInetAddress();
                System.out.println("当前客户端的IP为："+address.getHostAddress());
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }

}

（3） 创建客户端类
在后面的关闭资源中，我把输入输出相关的流关闭注释了，是因为对于同一个Socket，关闭socket的时候也会把输入输出流关闭，直接关闭socket就行，当然保留也是可以的。

package com.socket.test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

    public static void main(String[] args) {
         try {
                //创建客户端Socket，指定服务器地址和端口
                Socket socket = new Socket("localhost", 8089);
                //建立连接后，获取输出流，向服务器端发送信息
                OutputStream os = socket.getOutputStream();
                //输出流包装为打印流
                PrintWriter pw = new PrintWriter(os);
                //向服务器端发送信息
                pw.write("你好");//写入内存缓冲区
                pw.flush();//刷新缓存，向服务器端输出信息
                socket.shutdownOutput();//关闭输出流

                //获取输入流，接收服务器端响应信息
                InputStream is = socket.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                String data = null;
                while((data=br.readLine())!= null){
                    System.out.println("我是客户端，服务器端提交信息为："+data);
                }

                //关闭其他资源
                //br.close();
                //is.close();
                //pw.close();
                //os.close();
                socket.close();

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

    }

}

先运行服务器端，在运行客户端，效果展示

参考文献：
http://www.cnblogs.com/alimjan/p/7708892.html
https://www.cnblogs.com/zhaozihan/archive/2016/11/12/6057118.html