【发布时间】：2018-11-14 18:47:14
【问题描述】：
我正在尝试实现一个多线程套接字程序，该程序模拟五台计算机和一个控制器通过套接字相互通信。控制器有一个接受传入套接字（来自计算机）的服务器套接字。一旦达到系统的最大容量（比如说五个），它将使用在接受传入套接字时创建的线程向那些计算机发送启动消息。
当每台计算机从控制器接收到 Start 消息时，我希望每台计算机能够与其他计算机通信（不依赖于控制器（将消息从计算机中继到控制器到计算机）。我认为可行的是每台计算机都实例化一个服务器套接字，以便它可以接受来自计算机的传入套接字。并且还实例化另一个客户端套接字，以便来自不同计算机的其他服务器套接字可以接受它。
我知道这可能听起来很混乱，但基本上我想在每个客户端程序（计算机）上使用一个服务器套接字，以便它可以在不依赖控制器的情况下监听其他客户端（计算机）。
这可能吗？我可以为每个客户端程序（计算机）实例化一个服务器套接字，以便它可以监听其他计算机吗？它是否需要与控制器的服务器套接字不同的 IP 地址和/或端口号？我需要为 x 台计算机实例化 x 个套接字吗？
也许我的 Java 代码可以理解这一点。
Controller.java
package timetableexchange;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
public class Controller {
final int MAX_SYSTEMS = 2;
static ArrayList<ServerConnection> conns = new ArrayList<ServerConnection>(); // connections to computer
static int finishedCount = 0; // number of finished computers
ServerSocket ss; // server socket
public static void main(String[] args) throws IOException {
// Instantiate controller
new Controller(8000);
}
public Controller(int port) throws IOException {
// Instantiate server socket
ss = new ServerSocket(8000);
int i = 0;
// Listen and accept clients (1 for testing)
while (i < MAX_SYSTEMS) {
Socket s = ss.accept();
// add to list
ServerConnection conn = new ServerConnection(i++, s);
conns.add(conn);
}
// start server connection thread
for (i = 0; i < conns.size(); ++i) {
conns.get(i).start();
}
ss.close();
}
// Thread for communicating between controller and computer
private class ServerConnection extends Thread {
Socket socket;
BufferedReader in;
PrintWriter out;
int identifier;
// constructor
public ServerConnection(int i, Socket s) throws IOException {
this.identifier = i;
this.socket = s;
this.in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
this.out = new PrintWriter(socket.getOutputStream(), true);
System.out.println("Client Connected");
}
@Override
public void run() {
System.out.println("ServerConnection started");
// send ID to computers
sendAll(identifier + "");
// send Start message to computers
sendAll("Start");
// Check if a computer sent back a Finish message
// If all computers are finished, then send out Tear Down message.
while (true) {
try {
String clientInput = in.readLine();
if (clientInput.equals("Finish")) {
finishedCount += 1;
if (finishedCount == conns.size()) {
sendAll("Tear Down");
}
}
} catch (IOException e) {
e.printStackTrace();
break;
}
}
}
private void sendAll(String text) {
for (int i = 0; i < conns.size(); ++i) {
ServerConnection conn = conns.get(i);
conn.out.println(text);
}
}
}
}
计算机.java
package timetableexchange;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;
public class Computer {
final int MAX_SYSTEMS = 2;
int identifier; // Computer ID
int eventCount; // Number of Generated Events
ArrayList<Socket> sockets = new ArrayList<Socket>(); // List of (client) sockets
Vector<Integer> timestamp = new Vector<Integer>(); // Time-stamp vector
Socket socketToServer; // Socket to Connect to Controller
BufferedReader inputFromServer; // Input Stream from Controller
PrintWriter outputToServer; // Output Stream to Controller
String textFromServer; // String sent from Controller
ServerSocket ss; // Server Socket to communicate with other clients (computers)
Socket socketToClient; // Socket to Connect to Computer
BufferedReader inputFromClient; // Input Stream from Computer
PrintWriter outputToClient; // Output Stream to Computer
public static void main(String[] args) throws IOException {
// Instantiate Computer
new Computer("127.0.0.1", 8000);
}
// Constructor
public Computer(String hostname, int port) throws IOException {
// Instantiate Socket (to Controller) and Streams (to Controller)
socketToServer = new Socket(hostname, port);
inputFromServer = new BufferedReader(new InputStreamReader(socketToServer.getInputStream()));
outputToServer = new PrintWriter(socketToServer.getOutputStream(), true);
// Check if Controller sent the computer its ID
while (true) {
try {
textFromServer = inputFromServer.readLine();
// set identifier
identifier = Integer.parseInt(textFromServer);
System.out.println(identifier);
break; // break loop
} catch (NumberFormatException e) {
e.printStackTrace();
}
}
// Check if Controller sent the start message
while (true) {
textFromServer = inputFromServer.readLine();
if (textFromServer.equals("Start"))
System.out.println("Start message received");
break; // break loop
}
// Instantiate Server Socket (for Clients)
ss = new ServerSocket(port + identifier + 1);
// Instantiate Client Socket for Other Clients to Hear
socketToClient = new Socket();
inputFromClient = new BufferedReader(new InputStreamReader(socketToClient.getInputStream()));
outputToClient = new PrintWriter(socketToClient.getOutputStream());
// listen to server socket and add accepted socket to list
for (int i = 0; i < MAX_SYSTEMS - 1; ++i) {
Socket s = ss.accept();
System.out.println("Client accepted");
sockets.add(s);
}
Thread readEvent = new Thread(new Runnable() {
@Override
public void run() {
/**
* Read from input stream
* Read the vector inside the input stream
* Compare vectors and choose the largest integer (synchronized)
* Add 1 to the corresponding socket. (synchronized)
*/
}
});
Thread writeEvent = new Thread(new Runnable() {
@Override
public void run() {
/**
* Generate random number between 0 and 4.
* If zero, then add 1 to its own socket in vector.
* Else, send vector to random socket via output stream
*/
}
});
readEvent.start();
writeEvent.start();
}
}
感谢您的帮助！
【问题讨论】：
标签： java multithreading sockets serversocket distributed-system