java - 服务器套接字在第一次接收到数据后被阻塞

Question

我想问为什么服务器只在其中一个客户端第一次发送数据时显示，我的意图是有两个客户端并且只想发送一些整数，服务器读取它然后将其发送回其他客户端，然后等待该客户端发送信息并将其发送到其他客户端(切换它们)。但是只有第一次发送数据时，才会在服务器上读取数据？

服务器:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {

    private ServerSocket serv;
    private DataInputStream inFromClient1;
    private DataOutputStream outToClient1;
    private DataInputStream inFromClient2;
    private DataOutputStream outToClient2;

    public Server(){
        try {
            serv=new ServerSocket(8000);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void listen() throws IOException{
        System.out.println("Listening for connections");
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    Socket sock1;
                    Socket sock2;
                    try {
                        sock1 = serv.accept();
                        sock2=serv.accept();
                        handleSession(sock1,sock2);
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
            }
        }).start();

    }
    public void handleSession(Socket s1,Socket s2) throws IOException{
        DataInputStream in1=new DataInputStream(s1.getInputStream());
        DataOutputStream out1=new DataOutputStream(s1.getOutputStream());

        DataInputStream in2=new DataInputStream(s1.getInputStream());
        DataOutputStream out2=new DataOutputStream(s1.getOutputStream());
        while(true){

            int inint1=in1.readInt();
            System.out.println("Recived from 1 " + inint1);
            System.out.println("Sending to 2 ");
            out2.writeInt(in1.readInt());
            int inint2=in2.readInt();
            System.out.println("Recived from 2 " + inint2);
            System.out.println("Sending to 1 ");
            out1.writeInt(inint2);
        }
    }
    public static void main(String[] args) throws IOException {
        new Server().listen();
    }
}

Client : 

import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Client extends JFrame implements ActionListener{

    private JPanel mainPanel;
    private JButton[] buttons;
    private Socket socket;
    private int number;
    private DataInputStream fromServer;
    private DataOutputStream toServer;
    private boolean myTurn=true;

    public Client() throws UnknownHostException, IOException{
        mainPanel=new JPanel(new GridLayout(3,3));
        socket=new Socket("localhost",8000);
        add(mainPanel);
        addbuttons();
        setSize(new Dimension(500,400));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    private void addbuttons(){
        buttons=new JButton[9];
        for(int i=1;i<10;i++){
            buttons[i-1]=new JButton("Rectangle " + i);
            buttons[i-1].addActionListener(this);
            mainPanel.add(buttons[i-1]);
        }
    }
    public void actionPerformed(ActionEvent arg0) {
        JButton butt=(JButton) arg0.getSource();
        String str=butt.getText();
        String[] splitStr=str.split(" ");
        number=Integer.parseInt(splitStr[1]);
        System.out.println(number);
    }

    public void start() throws IOException{
        fromServer=new DataInputStream(socket.getInputStream());
        toServer=new DataOutputStream(socket.getOutputStream());

        new Thread(new Runnable() {

            @Override
            public void run() {
                Scanner in=new Scanner(System.in);
                while(true){
                    System.out.println("Write some integer");
                    int inint=in.nextInt();
                    System.out.println("Before " + myTurn);
                    if(myTurn){
                        try {
                            toServer.writeInt(inint);
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        myTurn=false;
                    }
                    else{
                        int fromServint=0;
                        try {
                            fromServint=fromServer.readInt();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println("Recived integer " + fromServint);
                        buttons[fromServint].setText("Some new Text");
                        myTurn=true;
                    }
                    System.out.println("After " + myTurn);
                }
            }
        }).start();
    }

    public static void main(String[] args) throws UnknownHostException, IOException {
        new Client().start();
    }
}

Answer 1

看起来您正在从客户端 1 读取 2 个整数(猜测这是一个拼写错误)，所以

尝试改变

out2.writeInt(in1.readInt());

至

out2.writeInt(inint1);

此外，正如 @JohnBollinger 提到的，

Separate Data*Streams are created, but both sets are connected to socket s1, instead of one set to each socket.

    DataInputStream in1=new DataInputStream(s1.getInputStream());
    DataOutputStream out1=new DataOutputStream(s1.getOutputStream());

    DataInputStream in2=new DataInputStream(s1.getInputStream());
    DataOutputStream out2=new DataOutputStream(s1.getOutputStream());

这里的所有流都引用同一个客户端。