io流+网络+线程池 实现简单的多客户端与服务器端通信

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
//客户端要做的事就是 读出服务器端输出的信息，将要说的话写到服务器端
public class Client {
public static void main(String[] args) {
    Socket client = null;
    OutputStream os  =null;
    InputStream is = null;
    Scanner sc= new Scanner(System.in);
    
    try {
        client= new Socket("127.0.0.1",5000);
        String address = client.getInetAddress().getHostAddress();
        is = client.getInputStream();
        int len=0;
        byte []b = new byte[1024];
        len=is.read(b, 0, b.length);
        System.out.println(new String(b,0,len));
        os = client.getOutputStream();
        String sendMsg=sc.next();
        os.write(sendMsg.getBytes());
        while(true) {
            len=is.read(b, 0, b.length);
            String msg = new String(b,0,len);
            System.out.println(msg);
            String send = sc.next();
            os.write(send.getBytes());
            os.flush();
            if(send.contains("bye")) //判断写出的字符串中是否包含bye 包含则退出
            {
                break;
            }
        }
        
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        try {
            is.close();
            os.close();
            client.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//服务器端接收多个客户端的连接 并处理每个连接要做的事情
public class Server {
    public static ServerSocket server;
    public static Socket client;

        //静态代码块只执行一次 跟随类加载
        //非静态匿名代码块 每次都跟随对象加载

    static {
        try {
            server = new ServerSocket(5000);
            System.out.println("服务器端已经创建，开放端口为5000");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
       //使用的线程池是newCachedThreadPool
    public static void main(String[] args) {
        ExecutorService exe = Executors.newCachedThreadPool();
        while(true) {
            try {
                client= server.accept();
                exe.execute(new SocketThread(client));
                
                
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
}
class SocketThread extends Thread {
    Scanner sc= new Scanner(System.in);
    private Socket s = null;
    private InputStream is= null;
    private OutputStream os= null;
    public SocketThread(Socket s) {
        this.s = s ;

    }
    @Override
    public void run() {
        try {
            os = s.getOutputStream();
            os.write("你好 请输入你的名字".getBytes());
            os.flush();
            is=s.getInputStream();
            byte []b = new byte[1024];
            int len=is.read(b, 0, b.length);
            //为线程设置名字
            setName(new String (b,0,len));
            os.write("恭喜设置昵称成功，我们开始聊天吧".getBytes());
            os.flush();
            while(true) {
                len=is.read(b, 0, b.length);
                String msg = new String(b,0,len);
                if(msg.contains("bye")) {
                    break;
                }
                System.out.println(getName()+":"+msg);
                String send =sc.next();
                os.write(send.getBytes());
                os.flush();

            }

        } catch (Exception e) {
            // TODO: handle exception
        }
        finally {
            try {
                os.close();
                is.close();
                s.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
87 }