Java套接字对象输出流多线程

Question

我有使用多线程将对象发送到 ServerSocket 的代码(当前在本地，但将来在本地网络中)

用于发送对象:

public class SocketToAdapter {

public static void writeObject(Object object) {
    try {

        give().writeUnshared(object);

    } catch (IOException e) {
        System.out.println(e.getMessage());
    }
}

static ObjectOutputStream give() {
    Socket s = null;
    try {
        s = new Socket("localhost", 9990);
        s.setTcpNoDelay(true);
        return new ObjectOutputStream(s.getOutputStream());

    } catch (UnknownHostException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return null;
}

主要方法:

SocketToAdapter soc = new SocketToAdapter();

    thread1.setSocket(soc);
    thread2.setSocket(soc);
    thread3.setSocket(soc);
    thread4.setSocket(soc);
    thread5.setSocket(soc);

    synchronized (valueExchanging) {
        synchronized (soc) {
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
            thread5.start();
        }

valueExchanging 是一个用于在线程之间交换数据的对象。

从线程运行方法:

public void run() {
    try {
        while (true) {
            curr = new Object(pair, RandomUtil.getRandomExchange(),
                    RandomUtil.getRandomTurn());
            //not important Business Logic.
                            int v1 = valueExchanger.getExchangeInTread()+1;
            int v2 = valueExchanger.getExchangeInTread()-100;
            curr = new Object(pair, BigInteger.valueOf(v1),
                    BigInteger.valueOf(v2));
                            //
            SocketToAdapter.writeObject(curr);
            valueExchanger.setExchangeInTread(v1);
            Thread.sleep(0, 1);
        }
    } catch (InterruptedException iex) {
    }
}

这有效，但速度非常慢。可能是因为我每次需要时都会创建 Socket 和 ObjectOutputStream。我尝试创建一个 Socket 和一个 OOS 并像这样使用它:

                   {
        Socket s = new Socket("localhost", 9990);
        ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream()); }

然后

oos.writeUnshared(object); 
oos.flush(); 
oos.writeUnshared(object);

但是，如果我第二次尝试重用 oos，我会收到“软件导致连接中止:套接字写入错误”。我使用多少线程并不重要。

我需要的是每秒发送许多(例如 100k)对象的可能性，有什么建议吗？

在服务器端我做:

Serwer.java:

    ServerSocket ss;
public static void pre()throws IOException, ClassNotFoundException {
    ss = new ServerSocket(9990);
    }

public static Object start() throws IOException, ClassNotFoundException {
    Object o = null;
    Socket s = ss.accept(); 
    while (!s.isClosed()) {
        ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
        o = (Object) ois.readObject();
        ois.close();
        s.close(); 
    }
    ss.close();
    return o;

}

“主要方法”

    while (true) { 

            try {
                Serwer.pre();
                Object o = Serwer.start();
                                    //im do somethink with that object o.
            } catch (IOException e1) {
                e1.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

Answer 1

在客户端中，它为发送的每个对象打开一个新的 TCP 连接。这会降低性能，因为建立 TCP 连接会产生大量开销。

从您的代码来看，服务器看起来像是在处理单个对象后关闭连接。它还会在处理单个连接后关闭 ServerSocket，这似乎根本不起作用。提供的服务器代码是否正确？服务器代码中是否存在另一个循环将启动另一个 ServerSocket？

最好的方法可能是让每个客户端线程创建自己的Socket，每个套接字都有一个到服务器的单独连接。如果您尝试推送大量数据并使用多个线程来实现此目的，那么服务器很可能需要多个线程来处理数据。这些套接字应该一次性创建并重用来发送所有对象。

在服务器端，您将需要创建一个适当的多线程 TCP 服务器。这里的总体思路是创建一个 SocketServer 并在 while 循环中调用其 accept() 方法。对于从 accept() 返回的每个 Socket，您将启动一个新线程来处理请求。可以在此处找到示例:Multithreaded Server using TCP in Java