I'm trying to send Events to the Esper engine through sockets and ran into some problem.
i've configured the EsperIOSocketAdapter properties and when EsperIOSocketAdapter.start() method is invoked , it starts a new daemon thread which will listen for clients , but daemon thread exits as parent thread exits before a socket client actually tries to connect.
my code snippet is as follows:
ConfigurationSocketAdapter adapterConfig = new ConfigurationSocketAdapter();
SocketConfig socket = new SocketConfig();
socket.setDataType(DataType.CSV);
socket.setPort(6789);
adapterConfig.getSockets().put("CourseSocket", socket);
EsperIOSocketAdapter socketAdapter = new EsperIOSocketAdapter (adapterConfig, "CourseSocket");
socketAdapter.start();
Another doubt is in programs without using the SocketAdapter i used to send events through the code
EPRuntime.sendEvent(new TestEvent(event));
While using SocketAdapter, shoud i use sendEvent() or events will automatically pushed into the engine.
Your socket problem seems to be of a generic nature where the JVM is terminating because you do not have any non-daemon threads running. Make the parent thread (or the socket thread) a non-daemon thread and the JVM will not terminate. (Make sure you can actually stop the thread or your JVM will be stubborn about shutting down :) )
When you use the SocketAdapter, your "sending client" is remote to the physical EPRuntime, but you use the remote socket to send events over the socket, as outlined in the docs.
Related
I'm working on a server/client solution which creates a new server-thread for each client that is connected (adds it to a thread pool). The server-thread waits for a message from the associated client by calling readLine() on the clients sockets input stream. If I set the thread pool to 1 and connect a second client it won't get executed by the thread pool until the first thread is shut down. I was under the impression that a thread pool would automatically idle a thread if it was just waiting on readLine() but I guess that is not the case. How would I go about creating such a program?
This is the server loop which creates new server-threads connected to a client:
private final static Executor executor = Executors.newFixedThreadPool(MAX_CLIENTS);
while (true) {
clientSocket = serverSocket.accept();
executor.execute(new ChatServer(clientSocket, allClients));
}
And the run-method works like this:
socketReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())
while(true) {
inputLine = socketReader.readLine();
//then send input line to all clients
}
As said if the FixedThreadPool is already running MAX_CLIENTS no new clients will get executed.
With Your current design You are going to run out of threads as the number of the the clients goes up. If Your thread pool is size of 20 threads, You cant handle 21 clients simultaneously. Because socket operations are blocking operations.(and Your ChatServer class will keep the executing thread busy with while(true) loop)
You should check AsynchronousSocketChannel and AsynchronousServerSocketChannel classes which support async IO operations. To be able to use these classes You have to change most of Your client server communication logic.
Check out the following links for details and example usage of these classess.
https://www.javaworld.com/article/2853780/socket-programming-for-scalable-systems.html
https://webtide.com/on-jdk-7-asynchronous-io/
I'm trying to write an emulator for a single-threaded physical product. It accepts one long-lived connection and any other connections get a single error message (in the same thread).
I know I can use java.net with two threads:
Thread 1 - start ServerSocket on port XXXX and wait for accept(). For the first connection create a Socket and Thread #2, and for other connections produce an error message.
Thread 2 - process the Socket IO.
But how can I do it with one thread, so it behaves more like the physical product (ie. repeatedly attempting connections would starve the thread from dealing with the first connection)?
Trying not to use third-party libraries, but can do if that's the only option.
Thanks!
Unfortunately the common java.net.ServerSocket as well as the java.nio.channels.ServerSocketChannel only feature a blocking method to accept incoming connections. However the java.nio package features many other classes and methods to handle I/O-Operations in a single thread by multiplexing the opened channels.
This approach would still enforce a dedicated Thread for the accepting ServerSocketChannel but you could handle every accepted connection in a single thread.
In comparison the ServerSocket approach needs one new thread for each new connection.
Imgaine you connect 100 clients using a ServerSocket then you will end up with 101 thread. With a ServerSocketChannel you could end up using only 2 thread.
Still programming is often about a tradeoff between complexity/flexibility and performance. So keep that in mind.
A possible solution I could think of could look like this:
public static void main( String[] args ) throws IOException
{
int portNr = 8080;
ExecutorService es = Executors.newSingleThreadExecutor();
ChannelHandler ch = new ChannelHandler();
es.execute( ch );
// Starting server:
ServerSocketChannel serv = ServerSocketChannel.open();
// Bind socket to Port
serv.socket().bind(new InetSocketAddress(portNr));
while( serverAlive )
{
ch.addChannel(serv.accept());
}
serv.close();
}
How you actually process the new added SocketChannel depends on your application. And so does the ChannelHandler#addChannel method.
It seems like you should accept the single connection and then close the ServerSocket. Any future connect attempts will then get a connection refusal. When the long-lived connection ends, create a new ServerSocket, accept one more connection, ... Rinse and repeat.
EDIT If you have to deliver an error message as per your comment below, you have to accept the connection to send it over, and if you have to do I/O and accepting all in one thread you have to use java.nio.channels.ServerSocketChannel/SocketChannel, non-blocking mode, and a Selector.
Using a ServerSocket with one Thread is not a good idea at all. WHY?
you know socket.accept() waits till the next client connects, so the Thread is blocked and if you only have one Thread your whole Programm is blocked till a Client connects.
May you explain why you try to do it single threaded?
So, I have a following problem:
I have a thread for client socket(for example SingleSocketThread). I create and start this thread if it is not alive and not created or socket is not connected else I do interrupt this thread and re-create new thread and start it and connect to socket server in runnable block. But when opened another activity or application enter to background mode(for example user press home button) I need disconnect socket but need keep SingleSocketThread and when return application to foreground I need connect socket to socket server again.
Anybody know how to right solve this problem? Anybody have a best way control thread and effective use created thread to using socket in another thread.
Is there a way to check for incoming connections to ServerSocket, so my server would not stop when waiting for someone to connect.
I need something like
try {
if (server.thereisarequest()) {
Socket socket = server.accept();
}
}
Are you sure you want this? Having the code presented, only one thread is waiting. Run another threads which handle accepted connections so that your server doesn't stop.
You can also use java non-blocking asynchronous I/O (nio and nio2), but in the background there is a thread on duty anyway.
Keep it simple... use an infinite while loop to make server look for the incoming request... thats how most of the servers works..
while (true) {
incoming = s.accept(); // incoming is of type Socket.
}
You can create a new thread to accept connections.
Then you have 2 choices:
Process the socket in a new thread
Put the sockets in a queue (ConcurrentLinkedQueue) and check it queue from you main thread.
I am from Ethiopia so i am sorry for my English
I was designing a muiltithread server/client application and the server has its own user interface that keep the list of all connected client the problem is
ss = new ServerSocket( port );
while (true) {
// Grab the next incoming connection
s = ss.accept();
ss.accept(); block the entire process and i am not able to access other functionalities of the server. the user interface of the server completly freez even though the server is accepting new clients and the client side is working perfectly.
so what shall i do to make the server accept new connection while processing other things
There are two (popular) ways of doing this:
A main thread containing a blocking loop waiting for clients. This main thread spawns a new Thread when a client is accepted.
Java New Input/Output. Everything is handled in the main thread. See http://rox-xmlrpc.sourceforge.net/niotut/index.html
Also: you point out your server application has a User Interface. A User Interface should be running in a different thread (the Event Dispatcher Thread, EDT) than the server.
you should spawn thread and call accept there
So Put this Listener ( in a method) and use TaskFactory. TaskFactory will execute the method in a separate thread and you will not have this problem