Java服务器客户端

Question

正在为我的XO游戏编写服务器。 基本思想是，我有一台计算机作为具有静态ip的服务器运行，而其他计算机可以连接到它。

它需要能够将游戏状态发送给所有连接的客户端，但是我遇到了阻塞问题。

如果您看看客户端

Scanner input = new Scanner();
int test = input.nextInt();

正在阻止代码。

服务器能够将消息发送给所有客户端，但是当它等待传递Int以回显游戏状态时（如设置一组int，坐标），nextInt（）阻止了该消息。

任何人都可以在这里帮助我，我真的很困惑，一直在阅读阻塞问题，在网络上以及在这里的论坛上，我发现有人在说我必须在客户端检查inputStream是否包含某些内容。还是没有，但我无法实现它。

任何想法，建议都欢迎。

谢谢大家的时间。

- - - -服务器 - - - - - -

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

public class Server extends SerResponse {

    public static void main(String[] args) {
        int port = 1234;
        int cliNum = 1;

        try {
            ServerSocket sock = new ServerSocket(port);
            System.out.println("SERVER WORKING......");
            int index0 = 0;

            while (true) {
                SerResponse ser = new SerResponse();
                Socket connection = sock.accept();
                soc[index0] = connection;
                index0++;

                if (connection != null) {
                    System.out.println("Client " + cliNum + " connected " + connection);
                    cliNum++;
                }

                Runnable runnable = new Server(connection, ++ser.count);
                Thread t = new Thread(runnable);
                t.start();
            }
        } catch (Exception e) {
            System.out.println("SERVER FAIL " + e);
        }
    }

    public Server(Socket s, int count) {
        this.connection = s;
        this.ID = count;
    }
}

------服务器响应--------------

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

public class SerResponse implements Runnable {

    public static Socket connection;
    public int ID;
    public final static int size = 10;
    public static Socket[] soc = new Socket[size];
    public int count = 0;
    public int test;

    public void run() {
        try {
            while (true) {
                DataInputStream in = new DataInputStream(connection.getInputStream());
                test = in.readInt();
                System.out.println("Recieved from " + connection + " " + test + "\n");

                for (int index0 = 0; index0 < size; index0++) {
                    if (soc[index0] != null) {
                        DataOutputStream out = new DataOutputStream(soc[index0].getOutputStream());
                        out.writeInt(test);
                        System.out.println("Sent to client " + soc[index0] + " " + test);
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("Runnable FAIL " + e);
        }
    }
}

- - -客户 - - - -

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

public class client {

    public static void main(String[] args) {
        int[][] arr = {{3, 4}, {6, 2}, {9, 2}};
        int[][] arr1 = new int[3][2];
        int port = 1234;
        int test;
        int test1;

        try {
            System.out.println("Starting client");
            Socket sock = new Socket("localhost", port);

            DataOutputStream out = new DataOutputStream(sock.getOutputStream());
            DataInputStream in = new DataInputStream(sock.getInputStream());

            Scanner input = new Scanner(System.in);
            int turn = 0;

            while (true) {
                test = input.nextInt();
                out.writeInt(test);
                System.out.println(test);
                test1 = in.readInt();
                System.out.println(test1);
                turn++;
            }
        } catch (Exception e) {
            System.out.println("CLIENT FAIL " + e);
        }
    }
}

Answer 1

这是对客户端类的重做，应该提供您要寻找的异步行为。

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client extends Thread {
    private final Socket sock;
    private boolean shutdown = false;

    public Client(Socket sock) {
        this.sock = sock;
    }

    public void shutdown() {
        shutdown = true;
    }

    public void writeDataToServer(int test) {
        try {
            synchronized(Client.class) {
                //don't allow reading and writing at the same time.
                DataOutputStream out = new DataOutputStream(sock.getOutputStream());
                out.writeInt(test);
                sock.getOutputStream().flush();
            }
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            BufferedInputStream bis = new BufferedInputStream(sock.getInputStream());
            while(!shutdown) {
                if(bis.available() > 0) {
                    synchronized(Client.class) {
                        DataInputStream in = new DataInputStream(bis);
                        int test = in.readInt();
                        //you can do something with test hereafter.... but since the example just had it printing out
                        System.out.println(test);
                    }
                } else {
                    Thread.sleep(500); //sleep for 500ms before polling again.
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                sock.close();
            } catch(Exception ignored){}
        }
    }


    public static void main(String[] args) {
        int[][] arr = {{3, 4}, {6, 2}, {9, 2}};
        int[][] arr1 = new int[3][2];
        int port = 1234;
        int test;

        try {
            System.out.println("Starting client");
            Client client = new Client(new Socket("localhost", port));
            client.start();

            Scanner input = new Scanner(System.in);
            int turn = 0;

            while(turn < 10) {
                test = input.nextInt();
                client.writeDataToServer(test);
                System.out.println(test);
                turn++;
            }

            client.shutdown();
        } catch(Exception e) {
            System.out.println("CLIENT FAIL " + e);
        }
    }
}