運用JAVA的concurrent.ExecutorService線程池實現socket的TCP和UDP連接

最近在項目中可能要用到socket相關的東西來發送消息，所以初步研究了下socket的TCP和UDP實現方式，並且結合java1.5的concurrent.ExecutorService類來實現多線程。

具體實現方式見代碼：

一、TCP方式：

1、服務端實現方式：

TCP的服務端實現方式主要用到ServerSocket類，接收等待客戶端連接的方法是accept();

代碼如下：類SocketServerTCP

private int port = 8823;
    private ServerSocket serverSocket;
    private ExecutorService executorService;// 線程池
    private final int POOL_SIZE = 100;// 單個CPU線程池大小

    public SocketServerTCP() {
        try {
            serverSocket = new ServerSocket(port);
            executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
                    .availableProcessors() * POOL_SIZE);
            logger.info("端口號為" + port + "的服務器啟動");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void service() {
        System.out.println("socket初始化成功！");
        logger.info("socket服務端初始化成功！");
        while (true) {
            Socket socket = null;
            try {
                // 接收客戶連接,只要客戶進行了連接,就會觸發accept();從而建立連接
                socket = serverSocket.accept();
                executorService.execute(new CallService(socket));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

 CallService類主要作用是接收到消息后，來實現具體業務。

代碼如下：

/**
 * 功能說明：執行具體業務的線程 
 */
  class CallService implements Runnable {
    Logger logger = Logger.getLogger(CallService.class);
    private Socket socket;
     
    private BufferedReader is;
    private PrintWriter os;
 
    public CallService(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        try {
            is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            os = new PrintWriter(socket.getOutputStream());

            String msg = is.readLine();

            System.out.println("接到客戶端消息" + msg);
            
            //返回消息給客戶端
            String responseMsg="服務端返回消息：" + msg;
            os.println(responseMsg);
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } 
    } 

服務器啟動方式：

public static void main(String[] args) {
        new SocketServerTCP().service();
    }

 

2、TCP客戶端實現代碼

客戶通過new Socket(ip, port)創建一個socket,並通過PrintWriter來向服務器發送消息

public class SocketClientTCP {
    public String sendMsg(String ip, int port, String msg) {
        Socket client = null;
        try {
            // 創建Socket
            client = new Socket(ip, port);

            // 向服務器發送消息
            PrintWriter out = new PrintWriter(new BufferedWriter(
                    new OutputStreamWriter(client.getOutputStream())), true);
            out.println(msg);
            out.flush();

            // 接收來自服務器的消息
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    client.getInputStream()));
            String str = in.readLine();
            // 關閉流
            out.close();
            in.close();
            // 關閉Socket
            client.close();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static void main(String[] args) {
        SocketClientTCP client = new SocketClientTCP(); 
        String str1 = client.sendMsg("127.0.0.1", 8823,"xiaoxi_1234567890A1234567!");
        System.out.println("str1=====" + str1);
    }
}

二、UDP實現方式

1、“服務端”實現方式

 

UDP的服務端主要是用到DatagramSocket、DatagramPacket類，通過new DatagramSocket(port)來創建一個socket，並且通過DatagramPacket來接收消息
代碼如下：類SocketServerUDP:

private int port = 1114;
    private DatagramSocket dataSocket;
    private ExecutorService executorService;// 線程池
    private final int POOL_SIZE = 100;// 單個CPU線程池大小

    public SocketServerUDP() {
        try {
            dataSocket = new DatagramSocket(port);
            executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
                    .availableProcessors() * POOL_SIZE);
            logger.info("端口號為" + port + "的服務器啟動");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void service() {
        System.out.println("socket初始化成功！");
        logger.info("socket服務端初始化成功！");
         
        while (true) { 
            try {
                 byte[] buff = new byte[128];// 傳輸消息不超過64字  
                 DatagramPacket dataPacket = new DatagramPacket(buff, buff.length);   
                 dataSocket.receive(dataPacket);// 等待接收來自客戶端的數據包   
                 
                 executorService.execute(new UdpCallService(dataPacket));//接收到消息后執行具體的業務
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

 UDPCallService類主要作用是接收到消息后，來實現具體業務。

代碼如下：

class UdpCallService implements Runnable {
    Logger logger = Logger.getLogger(UdpCallService.class);
    private DatagramPacket packet;   
    private DatagramSocket dataSocket;   

    public UdpCallService(DatagramPacket packet) {   
        try {
            this.packet = packet;   
            // 創建本機可以端口的DatagramSocket   
            dataSocket = new DatagramSocket();   
        } catch (SocketException e) {   
            e.printStackTrace();   
        }   
    }    

    public void run() {        
            String str=new String(packet.getData());            
            System.out.println("接收到消息："+str); 
            //返回數據給客戶端
            responeSocket("UDP消息返回："+str);  
    }
    
    //返回消息給客戶端
    public void responeSocket(String message){
         // 構造響應數據包   
        byte[] response = message.toString().getBytes();   
        DatagramPacket dataPacket = new DatagramPacket(response, response.length, packet.getAddress(), packet.getPort());   
        try {// 發送   
            dataSocket.send(dataPacket);   
        } catch (IOException e) {   
            e.printStackTrace();   
        }    
    }

服務器啟動方式：

public static void main(String[] args) {
        new SocketServerUDP().service();
    }

2、UDP客戶端實現方式

      UDP客戶端的實現方式與"服務端"實現方式差不多，因為UDP本身就沒有很嚴格的服務端和客戶端定義。

代碼如下：

public class SocketClientUDP {
    
    private int PORT;

    public SocketClientUDP(int PORT) {
        this.PORT=PORT;
    }

    public String getMessage() {
        String msg = "";
        try {

            String str = "hello world ";
            DatagramSocket socket = new DatagramSocket();

            // 發送UPD消息給服務端
            DatagramPacket requestPacket = new DatagramPacket(str.getBytes(),
                    str.length(), InetAddress.getLocalHost(), PORT);
            socket.send(requestPacket);

            // 接收服務端返回的UDP消息
            byte[] data = new byte[128];
            DatagramPacket responsePacket = new DatagramPacket(data,data.length);
            socket.receive(responsePacket);
            msg = new String(responsePacket.getData(), 0,responsePacket.getLength());
            socket.close();
        } catch (UnknownHostException e) {
            System.err.println("Exception: host could not be found");
        } catch (Exception e) {
            System.err.println("Exception: " + e);
            e.printStackTrace();
        }
        return msg;
    }
    
     public static void main(String[] args){
          SocketClientUDP clientUdp = new SocketClientUDP(1114); 
          String str1=   clientUdp.getMessage();
          System.out.println("str1====="+str1); 
     }

 

具體的JAVA文件下載地址：

http://files.cnblogs.com/fbsk/Socket_TCP_UDP.zip