I am creating a simple java program that creates two threads when it starts, each of these thread creates a server that listen to different port(ie port 5500, 5100), those servers each have clients, now i want the servers to be able to pass information from their client to each other. How do i do that. this is the code i have for the servers
class SocketSeverBrooker extends Thread{
int portNumber = 5500;
ServerSocket serverSocket = null;
int clientID = 10000;
public void run(){
try {
serverSocket = new ServerSocket(portNumber);
while(true){
try{
// i am accepting acconection from a client
Socket clientsocket = serverSocket.accept();
new Thread(new BrokerRunnable(clientsocket)).start();
System.out.println("a broker has connected with id "+ clientID);
clientID++;
}catch(IOException e){
System.out.println("client could not connect");
}
}
}catch (IOException e){
System.out.println("could not create a connection");
}
}
}
class BrokerRunnable implements Runnable{
protected Socket clientSocket;
public BrokerRunnable(Socket clientSocket) {
this.clientSocket = clientSocket;
}
public void run() {
// create two way communication
// this is used to get input from the connected client clientSocket.getInputStream()
// new BufferedReader();
try{
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),true);// write the sever
String arg1;
arg1 = in.readLine();
System.out.println( arg1);
Scanner scanner = new Scanner(System.in);
String msgToBrokker = scanner.nextLine();
out.println(msgToBrokker);
}catch(IOException e){
System.out.println("could not read");
}
}
}
I am unable to ask a question using a comment. Hence writing here. Sorry.
What i understood from the question, Please correct me if this is not the case.
We have multiple servers (S) and each may have multiple clients (C) too.
S1 -> S1C1, S1C2, ...., S1Cn
S2 -> S2C1, S2C2, ...., S2Cn
......
Sm -> SmC1, SmC2, ...., SmCn
Servers to share information with other servers that can be passed to clients.
If above understanding is correct, then you should have a common object (like a list, map) which can be shared by all the Servers. This object will store the information from all the servers. You will need to put a logic how will you which information to read by a server (for ex. S1 shouldn't read the information added by itself).
Hope this helps.
Related
Hello I am creating a server for the turn based game. I achieved connecting people to the server in the separated threads and they can send messages to server and recieve answer from server. However, now I need to connect two people to one room and make them communicate with each other (I do not know if through server or just somehow connect them with each other. These people connect to server and can communicate with it when every of them has one clientHandler. However, when I make a clientHandler which handles two sockets it does not work. Does somebody know how to make handler (room on a server) in which the pair of clients could send message to each other?
public void handlePVPGame(Socket playerWhite, Socket playerBlack, int pointerId) throws IOException {
int firstPlayerId = pointerId;
pointerId +=1;
int secondPlayerId = pointerId;
ClientHandler clientHandlerWhite = new ClientHandler(playerWhite);
ClientHandler clientHandlerBlack = new ClientHandler(playerBlack);
new Thread(clientHandlerWhite).start();
new Thread(clientHandlerBlack).start();
// This does not work
// TwoClientsHandler twoClientsHandler = new TwoClientsHandler(playerWhite, playerBlack);
// new Thread(twoClientsHandler).start();
// ClientHandlerClass
public class ClientHandler implements Runnable {
private final Socket clientSocket;
private PrintWriter printWriter;
private BufferedReader bufferedReader;
private InputStreamReader inputStreamReader;
public ClientHandler(Socket socket)
{
this.clientSocket = socket;
}
#Override
public void run() {
try {
printWriter = new PrintWriter(clientSocket.getOutputStream());
inputStreamReader = new InputStreamReader(clientSocket.getInputStream());
bufferedReader = new BufferedReader(inputStreamReader);
String receivedMessage;
while ((receivedMessage = bufferedReader.readLine())!= null){
System.out.printf(
" Sent from the client: %s\n",
receivedMessage);
printWriter.println("Welcome to server");
printWriter.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
// Class which does not work
public class TwoClientsHandler implements Runnable{
private final Socket playerWhite;
private PrintWriter printWriterWhite;
private InputStreamReader inputStreamReaderWhite;
private BufferedReader bufferedReaderWhite;
private final Socket playerBlack;
private PrintWriter printWriterBlack;
private InputStreamReader inputStreamReaderBlack;
private BufferedReader bufferedReaderBlack;
public TwoClientsHandler(Socket playerWhite,Socket playerBlack) {
this.playerWhite = playerWhite;
this.playerBlack = playerBlack;
}
#Override
public void run() {
try {
printWriterWhite = new PrintWriter(playerWhite.getOutputStream());
inputStreamReaderWhite = new InputStreamReader(playerWhite.getInputStream());
bufferedReaderWhite = new BufferedReader(inputStreamReaderWhite);
printWriterBlack = new PrintWriter(playerBlack.getOutputStream());
inputStreamReaderWhite = new InputStreamReader(playerBlack.getInputStream());
bufferedReaderWhite = new BufferedReader(inputStreamReaderWhite);
String receivedMessage;
while ((receivedMessage = bufferedReaderWhite.readLine())!= null){
System.out.printf(
" Sent from the client: %s\n",
receivedMessage);
printWriterWhite.println("Welcome to server");
printWriterWhite.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
I suggest sticking to a one-thread one-client approach. It is a much simpler solution requiring the creation of the protocol according to which users will send the messages. Say, your game is chess. Mike opens the application:
You create a separate thread for Mike and give him some UUID
You assign this UUID to the specific room
You keep UUID as a key and Room as the value in the ConcurrentHashMap
Room has an array of UUIDs and potentially whose the next turn
In the Server thread, you assign to Mike UUID 5 and room 3. Now when Mike wants to move his bishop to D5, he sends for example 5BD5. Then:
You parse this message according to your protocol, so you extract UUID from the first character of the message -- 5, chess piece -- B, being bishop and square of the chessboard -- D5.
Having UUID extracted you immediately have a room and from the room you have the second player whom potentially you'd like to pass the messages from Mike.
This way you have perfectly separated rooms from one another. The server will convey the messages between the users only within the same room.
You can have several threads in one socket using Java NIO Selector, however, for your purpose above solution seems to be simpler.
hey I'm writing a simple code with a server socket and multiple clients which the server gets every client's username and stores them in a hashmap.the server accepts a socket client and the client enters the username but again the server accept the same socket client and it wants its username and the code stops here.i want it to work for multiple clients not just one.
server class:
public class Server implements Serializable{
// [..]
public void serverConnect() throws IOException, ClassNotFoundException
{
listener = new ServerSocket(9090);
System.out.println("Server is running...");
while (true)
{
System.out.println("Waiting ...");
socket=listener.accept();
for (Socket socket:socketList.keySet())
{
if (this.socket==socket)
{
checkSocket=false;
}
}
if (checkSocket)
{
socketList.put(socket,socketNumber);
System.out.println("Client is connected");
inputReader = new InputStreamReader(socket.getInputStream());
reader = new BufferedReader(inputReader);
user = reader.readLine();
Server.userList.add(user);
socketNumber++;
}
checkSocket=true;
}
}
}
client class:
public class Client {
public Client() {
}
public void clientConnect() throws UnknownHostException, IOException {
System.out.println("enter your username");
Scanner scanner = new Scanner(System.in);
String msg = scanner.nextLine();
Socket socket = new Socket("localhost", 9090);
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
writer.println(msg);
}
}
In principle you have the workings of single thread server (which means it can accept only one client connection at a time). The main issue is that you have over-complicated how you receive a connection.
You can simplify your current code by dealing by moving the client connection socket and readers into the local scope and dealing with the socket directly.
public void serverConnect() throws IOException {
listener = new ServerSocket(9090);
System.out.println("Server is running...");
while (true) {
System.out.println("Waiting ...");
Socket socket = listener.accept();
try (BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
String user = reader.readLine();
Server.userList.add(user);
} catch (IOException ignore) {
} finally {
socket.close();
}
}
}
As you can see you don't need to keep hold of the socket beyond reading the value sent. If you are only expecting the one line of data from the client, you should also close the socket otherwise the client can hold the server hostage by not sending any data until the socket timeout is reached.
Further to this you also want to wrap the code inside the while loop with a try/catch block to prevent an exception terminating the server.
As I mentioned in the opening paragraph this code works as a single threaded server and it can only respond to a single request at a time. If you want to accept and process multiple requests you will need to spawn a new thread to handle the response. I would recommend constructing your code as below but for the sake of brevity you could do something like below:
public void serverConnect() throws IOException {
int MAX_WORKERS = 100;
ExecutorService service = Executors.newFixedThreadPool(MAX_WORKERS);
ServerSocket listener = new ServerSocket(9090);
System.out.println("Server is running...");
while (true) {
System.out.println("Waiting ...");
Socket socket = listener.accept();
service.submit(() -> {
System.out.println("Client is connected");
try {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
String user = reader.readLine();
Server.userList.add(user);
} finally {
socket.close();
}
} catch (Throwable ignore) {
}
});
}
}
So all that is happening above is that we are creating a thread pool of 100 threads using the ExecutorService. This means in theory we can accept 100 concurrent connections.
When a connection is accepted, we submit the socket and worker code to a thread which means that the main thread can return to listening for a new connections.
I am trying to improve the speed at which the sockets transfer information but i am unsure how to do so. the pourpose of the code is to transfer a number, the date, and a short xml which is being sent in the form of a string.
this is the server code
import java.net.*;
import java.io.*;
public class SSocket extends Thread
{
private ServerSocket serverSocket;
public SSocket(int port) throws IOException
{
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(100000);
}
public void run()
{
System.out.println("Waiting for client on port " + serverSocket.getLocalPort() + "...");
while(true)
{
try
{
Socket server = serverSocket.accept();
DataInputStream in = new DataInputStream(server.getInputStream());
int cor=in.readInt();
int i=0;
String transaccion = in.readUTF();
String fecha = in.readUTF();
System.out.println(cor);
System.out.println(transaccion);
System.out.println(fecha);
DataOutputStream out =
new DataOutputStream(server.getOutputStream());
if(transaccion!=null && fecha != null && cor>0){
out.writeInt(cor);
}
else {
out.writeInt(-1);
}
if (i==100){
out.flush();
i=0;
}
i++;
server.close();
}catch(SocketTimeoutException s)
{
System.out.println("Socket timed out!");
break;
}catch(IOException e)
{
e.printStackTrace();
break;
}
}
}
public static void main(String [] args)
{
int port = 1337;
try
{
Thread t = new SSocket(port);
t.start();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
the code for the client is
import java.net.*;
import java.io.*;
public class ClientSocket
{
public static void send(int correl, String transaccion, String fecha)
{
String serverName = "localhost";
int port = 1337;
try
{
Socket client = new Socket(serverName, port);
int i=0;
OutputStream outToServer = client.getOutputStream();
DataOutputStream out =
new DataOutputStream(outToServer);
out.writeInt(correl);
out.writeUTF(transaccion);
out.writeUTF(fecha);
InputStream inFromServer = client.getInputStream();
DataInputStream in =
new DataInputStream(inFromServer);
int corin=in.readInt();
if(corin>0){
Envio.updater(corin);
}
else {
}
if (i==100){
out.flush();
i=0;
}
i++;
client.close();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
i have done some reading on the mater and it seems that posible solutions are to use either a buffer or swich to a datagram. however my experience on working with sockets is rather limited and i am unsure which would be best to use for this situation or if there is another option i havent yet considered. this code will be moving many transactions and i wish to do it in as short time as posible.
thanks in advance
ps. sorry for my bad english it is not my first language
Datagrams imply UDP, which is an unreliable delivery protocol so you're not guaranteed to get all content. That's probably not what you want; I'd stay with plain Sockets (which use TCP, which has reliable delivery).
Will the same client be calling send() repeatedly and connecting to the same server each time? That is, will there be many messages going across a single connection, or will each message be to a different server, with only a single message (or only a few) going to each of the many servers? If there's just one server that a client is going to connect to and if a given client is going to send lots of messages, you should keep the Socket open between send() calls; setting up and tearing down Sockets is expensive, so you're paying a high price for making a new connection each time.
Also, your server appears to only be able to handle a single connection at a time: you accept a connection, read from it, and then close it and accept a new one. So to make this work for more than one client, you'll need to separate the logic for accepting connections onto a different thread from the logic that reads data. If you'll only have a few clients at a time, you can just start a new thread to read from each socket as you create it for a new client; if you'll have lots of clients (thousands), you'll probably need to look at NIO for its ability to service multiple sockets from a single thread. But I suspect you're a long way from having that problem, if you ever do, so I'd just spawn a new thread for each socket.
i'm trying create "multi-client -- single server" connection.
My client(s) opens connection and in the server side I've create
Client clt = new Client("127.0.0.1", 9000);
clt.openConn();
...
public Client(String serverAddress, int serverPort) {
this.serverAddress = serverAddress;
this.serverPort = serverPort;
}
try {
this.clientSocket = new Socket(this.serverAddress, this.serverPort);
this.clientSocket.setKeepAlive(true);
this.clientSocket.setSoTimeout(0);
oos = new DataOutputStream(this.clientSocket.getOutputStream());
ois = new DataInputStream(this.clientSocket.getInputStream());...}
...
on the server side i've created ListArray of ServerSocket's each onf them I wrapped on the Thread.
ServerSocket serverSocket = null ;
Socket clientSocket;
boolean listening = true;
ArrayList threadList = new ArrayList();
Iterator itSrvThr;
try {
serverSocket = new ServerSocket(port);
} catch (IOException e) {
System.err.println("Could not listen on port: " + port + ".");
System.exit(-1);
}
while (listening) {
clientSocket = serverSocket.accept();
ServerThread srvThread = new ServerThread(clientSocket);
srvThread.start();
`...`
}
where
ServerThread extends Thread
{...
public void run() {
this.ois = new DataInputStream(socket.getInputStream());
this.oos = new DataOutputStream(socket.getOutputStream());
}
}
my program send and receive objects(i've called them "Datagramm") which are some kind of wrappers for file and strings (let us say it is some language for client-server)
And now about problem which I have. I must to make verification every time when need to test for "alive" socket from server side...
i'm trying to make this verification when appears new element in the ArrayList in that moment but it brings me problem with "Datagramm's" sending
itSrvThr = threadList.iterator();
while (itSrvThr.hasNext()) {
ServerThread st = (ServerThread) itSrvThr.next();
boolean stoppedSocket = st.getStopped();
if (stoppedSocket) {
st.stop();
itSrvThr.remove();
}else {??? resolution???}
stoppedSocket - it's a value which significate programly turned off socket from client site.
Honestly, i'm working with sockets and threads only a couple weeks, that is why every help and critics will be acceptable.
...
Thank for answer but I have problems with codding of heartbeats. First of them where exactly the place of heartbeat must be placed on the server side.
I suggest you send a heartbeat message from the client and/or the server whenever you haven't sent a message for a while (seconds) The other end can timeout when you haven't recieved anything for some multiple of this time.
If you have a protocol like {message length} {message} I use a message-length=0 as a heartbeat.
I'm trying to test a scenario where one server accepts connections(one each time) from one client, using always the same ports (on the server and on the client side).
The purpose is to have 1 client application sending little pieces of data at a rate bigger than 100/min. The well obvious solution would be to have an always connected link between the client and the server, but this is production stuff, and that would require bigger changes in the code that is already implemented. With the solution we have implemented today, we always have +-1K of connections in TIME_WAIT, and I want to get rid of them.
I have implemented a simple tester, and the code is:
public class Server {
public static void main(String[] args) {
ServerSocket ssock = null;
try {
ssock = new ServerSocket();
ssock.bind(new InetSocketAddress(Common.SERVER_PORT));
} catch (IOException e) {
e.printStackTrace();
System.exit(-1);
}
while(true){
try{
Socket cSock = ssock.accept();
BufferedReader reader = new BufferedReader(new InputStreamReader(cSock.getInputStream()));
reader.readLine();
PrintWriter writer = new PrintWriter(cSock.getOutputStream());
writer.println(Common.SERVER_SEND);
writer.flush();
reader.close();
writer.close();
cSock.close();
}catch (Exception e) {
System.out.println(e.getClass().getName() + ": " + e.getMessage());
}
}
}
}
public class Client {
public static void main(String[] args) throws Exception {
InetSocketAddress cliAddr = new InetSocketAddress(
InetAddress.getByName(args[0]),
Common.CLIENT_PORT);
InetSocketAddress srvAddr = new InetSocketAddress(
InetAddress.getByName(args[1]),
Common.SERVER_PORT);
for(int j=1;j<=50;j++){
Socket sock = null;
try{
sock = new Socket();
sock.setReuseAddress(true);
sock.bind(cliAddr);
sock.connect(srvAddr);
PrintWriter writer =
new PrintWriter(
sock.getOutputStream());
writer.println(Common.CLIENT_SEND);
writer.flush();
BufferedReader reader =
new BufferedReader(
new InputStreamReader(
sock.getInputStream()));
reader.readLine();
}catch (Exception e) {
System.out.println(e.getClass().getName() + ": " + e.getMessage());
System.exit(-1);
}finally{
if(sock!=null) sock.close();
System.out.println("Done " + j);
}
}
}
}
public class Common {
public static final int SERVER_PORT = 9009;
public static final int CLIENT_PORT = 9010;
public static final String CLIENT_SEND = "Message";
public static final String SERVER_SEND = "OK";
}
When executing the client and server, on windows hosts, in one client execution I always get
java.net.ConnectException: Connection timed out
When executing the client and the server in linux hosts, on some client executions I get a
java.net.NoRouteToHostException: Cannot assign requested address
I've been killing my head over this behavior. Can someone please tell me if it is possible to do what I want, and what I am doing wrong?
If you want to get rid of the TIME_WAIT state, don't be the peer that receives the close. Be the peer that initiates the close. In this case, close the connection immediately after reading the response, and have the server cycle around looking for another request so that it reads the EOF rather than just closing the connection immediately after sending the response. However this will only make the problem worse, as all the TIME_WAIT states will accumulate at the server rather than at the client. On the other hand, the server is now structured to accept multiple requests per connection, so then all you have to do is adapt the clients to use a connection pool and all your problems are solved.