Socket+多线程案例

不用多线程

package com.ego.com.ego.socket;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8888);

            //输出流，输出给服务器
//            OutputStream os = socket.getOutputStream();
//            os.write("hello server".getBytes());
            /*
            缓冲流加快效率。
            因为参数是Writer字符流，但socket返回的是字节流，
            所以使用转换流OutputStreamWriter，同时指定字符集
             */
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));

            //用户键盘输入
            Scanner scanner = new Scanner(System.in);
            String str;
            str = scanner.nextLine();


            //发送给服务器
            writer.write(str);
            writer.newLine();
            writer.flush();

//            //输入流，用于接收服务器返回的消息
//            InputStream is = socket.getInputStream();
//            byte[] bytes = new byte[1024];
//            is.read(bytes);
//            System.out.println(new String(bytes, 0, bytes.length));

            //缓冲输入流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
            String msg = reader.readLine();
            System.out.println(msg);


            //释放资源
            writer.close();
            reader.close();
            socket.close();

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

package com.ego.com.ego.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);

            //死循环，让服务器不关闭
            while(true){
                //建立连接
                Socket socket = serverSocket.accept();

//            //输入流，接收客户端发来的数据
//            InputStream is = socket.getInputStream();
//            byte[] bytes = new byte[1024];
//            is.read(bytes);
//            System.out.println(new String(bytes));

                //缓冲输入流
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
                String msg = reader.readLine();
                System.out.println(msg);

//            //输出流，回写给客户端
//            OutputStream os = socket.getOutputStream();
//            os.write("hello~".getBytes());
                //缓冲输出流
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
                writer.write("hello~");


                //释放资源
                //注意先开后关，不然可能抛异常
                writer.close();
                reader.close();
                socket.close();

                //如果输入exit，则关闭服务器
                if("exit".equalsIgnoreCase(msg)){
                    break;
                }
            }

            serverSocket.close();

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

使用多线程

package com.ego.com.ego.socket;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8888);

            /*
            缓冲流加快效率。
            因为参数是Writer字符流，但socket返回的是字节流，
            所以使用转换流OutputStreamWriter，同时指定字符集
             */
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));

            //用户键盘输入
            Scanner scanner = new Scanner(System.in);
            String str;
            str = scanner.nextLine();

            //发送给服务器
            writer.write(str);
            writer.newLine();
            writer.flush();


            //缓冲输入流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
            String msg = reader.readLine();
            System.out.println(msg);


            //释放资源
            writer.close();
            reader.close();
            socket.close();

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

package com.ego.com.ego.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);

            //死循环，让服务器不关闭
            List<Object> list = new ArrayList<>();
            while(true){
                //建立连接
                Socket socket = serverSocket.accept();

                //开启线程
                Thread thread = new Thread(new MyRunnable(socket));
                list.add(thread);
                thread.start();
                System.out.println(list.size());
                if(list.size() == 0){
                    break;
                }

//                //如果输入exit，则关闭服务器
//                if("exit".equalsIgnoreCase(msg)){
//                    break;
//                }
            }

            serverSocket.close();

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

package com.ego.com.ego.socket;

import java.io.*;
import java.net.Socket;

public class MyRunnable implements Runnable{

    private Socket socket;

    @Override
    public void run() {


        try {

            //缓冲输入流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
            String msg = reader.readLine();
            System.out.println(msg);

            //缓冲输出流
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
            writer.write("hello~");

            //释放资源
            //注意先开后关，不然可能抛异常
            writer.close();
            reader.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }



    }

    public MyRunnable(Socket socket) {
        this.socket = socket;
    }
}

使用Callabe代替Runnable

package com.ego.com.ego.socket;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8888);

            /*
            缓冲流加快效率。
            因为参数是Writer字符流，但socket返回的是字节流，
            所以使用转换流OutputStreamWriter，同时指定字符集
             */
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));

            //用户键盘输入
            Scanner scanner = new Scanner(System.in);
            String str;
            str = scanner.nextLine();

            //发送给服务器
            writer.write(str);
            writer.newLine();
            writer.flush();


            //缓冲输入流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
            String msg = reader.readLine();
            System.out.println(msg);


            //释放资源
            writer.close();
            reader.close();
            socket.close();

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

package com.ego.com.ego.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);

            //死循环，让服务器不关闭
            while(true){
                //建立连接
                Socket socket = serverSocket.accept();

                //创建Future实现类，保存线程的返回值
                FutureTask<String> futureTask = new FutureTask<>(new MyCallable(socket));

                //开启线程
                new Thread(futureTask).start();

                String msg = futureTask.get();

                //如果输入exit，则关闭服务器
                if("exit".equalsIgnoreCase(msg)){
                    break;
                }
            }

            //serverSocket.close();

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

package com.ego.com.ego.socket;

import java.io.*;
import java.net.Socket;
import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private Socket socket;

    @Override
    public String call() throws Exception {
        String msg = null;
        try {

            //缓冲输入流
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
            msg = reader.readLine();
            System.out.println(msg);

            //缓冲输出流
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
            writer.write("hello~");

            //释放资源
            //注意先开后关，不然可能抛异常
            writer.close();
            reader.close();
            socket.close();


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

    public MyCallable(Socket socket) {
        this.socket = socket;
    }
}