Java 多线程服务器中的线程连接

我正在用一个多线程服务器实现一个客户机-服务器程序，该服务器有一个ArrayList，各种客户机向其中发送数据，并将其添加到ArrayList中

客户：

package p2pclient;

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

public class client {
    public static void main(String[] args) {
        Socket smtpSocket = null;  
        DataOutputStream os = null;
        DataInputStream is = null;
        Scanner s = new Scanner(System.in);

        try {
            smtpSocket = new Socket("localhost", 8888);
            os = new DataOutputStream(smtpSocket.getOutputStream());
            is = new DataInputStream(smtpSocket.getInputStream());
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: hostname");
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for the connection to: hostname");
        }

        if (smtpSocket != null && os != null && is != null) {
            try {
                while(true)
                {
                    os.flush();
                    System.out.println("enter line");
                    String a = s.nextLine();
                    os.writeBytes(a + "\n");

                    System.out.println("wrote bytes");
                    String responseLine;

                    responseLine = is.readLine();
                    System.out.println("Server: " + responseLine);
                    if (responseLine.indexOf("Ok") != -1) {
                        System.out.println("breaking");
                        break;
                    }
                }
                os.close();
                is.close();
                smtpSocket.close();  
            } catch (UnknownHostException e) {
                System.err.println("Trying to connect to unknown host: " + e);
            } catch (IOException e) {
                System.err.println("IOException:  " + e);
            }
        }
        System.out.println("out of while");
    }           
}

---

服务器线程：

package server;

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ServerThread {

    public static void main(String args[]) throws InterruptedException {
        ServerSocket echoServer = null;
        Scanner s = new Scanner(System.in);
        String line;
        ArrayList<String> add_list = new ArrayList<String>();
        Collections.synchronizedList(add_list);
        int number=0;
        DataInputStream is;
        PrintStream os;
        Socket clientSocket = null;
        try {
            echoServer = new ServerSocket(8888);
        }
        catch (IOException e) {
            System.out.println(e);
        }   

        List<Thread> threads = new ArrayList<Thread>();
        while(true) {
            try {
                clientSocket = echoServer.accept();

                /* start a new thread to handle this client */
                number++;

                Thread t = new Thread(new ClientConn(clientSocket,number,add_list));
                t.start();
                threads.add(t);

            }catch (IOException e) {
                System.err.println("Accept failed.");
                System.err.println(e);
                System.exit(1);
            } 
            for (Thread t2 : threads)
            {
                t2.join();
            }
            System.out.println(add_list);
        }      
    }
}

包服务器；
导入java.io.*；
导入java.net。*；
导入java.util.*；
导入java.util.concurrent.CopyOnWriteArrayList；
公共类服务器线程{
公共静态void main（字符串args[]）引发InterruptedException{
ServerSocket echoServer=null；
扫描仪s=新的扫描仪（System.in）；
弦线；
ArrayList add_list=新建ArrayList（）；
集合.同步列表（添加列表）；
整数=0；
数据输入流为；
打印流操作系统；
套接字clientSocket=null；
试一试{
echoServer=新服务器套接字（8888）；
}
捕获（IOE异常）{
系统输出打印ln（e）；
}   
List threads=new ArrayList（）；
while（true）{
试一试{
clientSocket=echoServer.accept（）；
/*启动一个新线程来处理此客户端*/
数字++；
线程t=新线程（新客户端连接（客户端套接字、编号、添加列表））；
t、 start（）；
添加（t）；
}捕获（IOE异常）{
System.err.println（“接受失败”）；
系统错误println（e）；
系统出口（1）；
} 
用于（螺纹t2：螺纹）
{
t2.连接（）；
}
System.out.println（添加列表）；
}      
}
}

---

服务器可运行进程：

 package server;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.ArrayList;

class ClientConn implements Runnable {

    Socket client;
    DataInputStream in;
    DataOutputStream out;
    int s;
    ArrayList<String> al = new ArrayList<String>();

    ClientConn(Socket client,int s, ArrayList<String> al){
        this.client = client;
        this.s = s;
        this.al = al;

        try {
            in = new DataInputStream(client.getInputStream());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            out = new DataOutputStream(client.getOutputStream());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @SuppressWarnings("deprecation")
    @Override
    public void run() {
        // TODO Auto-generated method stub
        String response = "";

        try { 
            while (true) {
            response = "";
            response = in.readLine();
            out.writeBytes(response+"\n");
            if (response.indexOf("Ok") == -1)
                al.add(response);
            //  System.out.println(response);
            out.flush();
            if (response.indexOf("Ok") != -1) {
                //System.out.println("breaking");
                break;
            }
        }   
        } catch (IOException e) {
            System.err.println(e);
        }
    }
}

包服务器；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.Socket；
导入java.util.ArrayList；
类ClientConn实现Runnable{
套接字客户端；
数据输入流输入；
数据输出流输出；
int-s；
ArrayList al=新的ArrayList（）；
ClientConn（套接字客户端、int s、ArrayList al）{
this.client=client；
这个.s=s；
this.al=al；
试一试{
in=新的DataInputStream（client.getInputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
out=新的DataOutputStream（client.getOutputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
@抑制警告（“弃用”）
@凌驾
公开募捐{
//TODO自动生成的方法存根
字符串响应=”；
试试{
while（true）{
答复=”；
response=in.readLine（）；
out.writeBytes（响应+“\n”）；
if（response.indexOf（“Ok”）=-1）
al.add（回复）；
//System.out.println（响应）；
out.flush（）；
if（response.indexOf（“Ok”）！=-1）{
//系统输出打印（“中断”）；
打破
}
}   
}捕获（IOE异常）{
系统错误println（e）；
}
}
}

我试图将所有线程放在一个ArrayList中，并连接主线程上的每个线程。这是行不通的。相反，每个线程在第一个线程上等待

---

如何使主线程在打印数组列表之前等待其他线程结束？

尝试将

服务器
线程中的
循环更改为：

while(true) {
    try {
        clientSocket = echoServer.accept();
        number++;
        Thread t = new Thread(new ClientConn(clientSocket,number,add_list));
        t.start();
        t.join();
        threads.add(t);
    } catch (IOException e) {
            System.err.println("Accept failed.");
            System.err.println(e);
            System.exit(1);
    } 
    System.out.println(add_list);
}

我不明白-您在等待accept（）并在客户端连接时创建clientserver线程，然后立即等待它完成吗？直到第一个客户机线程终止，您才能返回accept（）。