TCP+多线程实现文件多个客户端上传文件

自定义客户端线程

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ClientRunnbale implements Runnable {
    private String ip = "127.0.0.1";
    private int port = 6666;
    String name = "E:/待上传文件.txt";


    public ClientRunnbale() {
        super();
    }

    public ClientRunnbale(String ip, int port, String name) {
        super();
        this.ip = ip;
        this.port = port;
        this.name = name;
    }


    @Override
    public void run() {
        try (// 1.创建客户端Socket对象，并指定ip跟端口
            Socket s = new Socket(ip, port);

            // 3.从指定的路径中读取要上传的文件上传到服务端
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(name));){

            // 2.将Socket中封装好的字节输出流包装成缓冲字节输出流
            BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());

            // IO流经典4行代码
            byte[] b = new byte[1024];
            int len;
            while ((len = bis.read(b)) != -1) {
                bos.write(b, 0, len);
            }
            bos.flush();

            // 告诉服务端，客户端已经上传完毕
            s.shutdownOutput();

            // 4.获取服务端的返回结果
            // 将Socket中封装好的字节输入流包装成字节缓冲输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            // 读取
            String string = br.readLine();
            System.out.println(string);

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

    }

}

服务端自定义线程

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.UUID;

public class ServerRunnable implements Runnable {

    private Socket socket;

    public ServerRunnable(Socket socket) {
        super();
        this.socket = socket;
    }

    @Override
    public void run() {
        try (//4.将客户端上传的文件保存到指定的路径中
            //为防止文件名重复     用UUID随机数+当前上传的毫秒值
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/"+UUID.randomUUID().toString().replaceAll("-", "")+System.currentTimeMillis()+".txt"));){

            //3.将ServerSocket中封装好的输入流包装成字节输入流
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
            //IO流经典4行代码
            byte[] b = new byte[1024];
            int len;
            while((len=bis.read(b))!=-1){
                bos.write(b, 0, len);
            }

            //5.通过客户端连接对象获取字节输出流并包装成字节缓冲输出流
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            bw.write("文件上传成功");
            bw.newLine();
            bw.flush();

        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try {
                socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
}

自定义线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolUtils {

    //1.创建一个私有的静态的线程池
    private static ExecutorService threadPool = Executors.newCachedThreadPool();

    //2.自定义一静态的execute方法
    public static void execute(Runnable command){//参数传进来的是实现了Runnable接口的一个线程
        //判断线程池是否结束，如果结束就重新创建线程池
        if(threadPool.isShutdown()){
            threadPool = Executors.newCachedThreadPool();
        }else{
            //如果没有停止就调用Executor他本身的execute方法
            threadPool.execute(command);
        }
    }

    //3.自定义一个静态的结束方法
    public static void shutdown(){
        //判断是否结束，如果没有结束就结束次常量池
        if(!threadPool.isShutdown()){
            threadPool.shutdown();
        }
    }
}

客户端跟服务端调用线程实现

客户端

public class Client {

    public static void main(String[] args) {
        //创建自己自定义的客户端线程
        ClientRunnbale cr = new ClientRunnbale();
        ClientRunnbale cr2 = new ClientRunnbale();
        ClientRunnbale cr3 = new ClientRunnbale();
        //调用自己自定义的线程池来开启线程
        ThreadPoolUtils.execute(cr);
        ThreadPoolUtils.execute(cr2);
        ThreadPoolUtils.execute(cr3);
    }
}

服务端

import java.net.ServerSocket;

public class Server2 {

    public static void main(String[] args) throws Exception {

        // 1.创建服务端ServerSocket对象，并指定端口号
        ServerSocket socket = new ServerSocket(6666);

        // 2.无限循环接受客户端发的请求
        while (true) {
            //创建自己自定义的服务端线程
            ServerRunnable sr = new ServerRunnable(socket.accept());
            //调用自己自定义的线程池来开启线程
            ThreadPoolUtils.execute(sr);
        }
    }
}