Fontaigne

First the SBOD then crash. Is this because of a threading issue? I basically created a while(true){listen to the socket} method. Any advice? Anywhere I should look in particular?

First the SBOD then crash. Is this because of a threading issue?  I basically created a while(true){listen to the socket} method.  Any advice?  Anywhere I should look in particular?


trying-to-create-a-mxj-socket-listener

On 30 Oct 2007, at 20:40, Timothy Dalbey wrote:

> First the SBOD then crash. Is this because of a threading issue?

Probably: I've written socket listeners for MXJ without any problems.

Here's a hack to an O'Reilly demo I did some years ago to demo how to 

build a TCP/IP server for MXJ. (Apologies to everyone else for the 

// This example is from _Java Examples in a Nutshell_. (

// This example is provided WITHOUT ANY WARRANTY either expressed or 

// You may study, use, modify, and distribute it for non-commercial 

http://www.davidflanagan.com/javaexamples

* This class is a generic framework for a flexible, multi-threaded 

* It listens on any number of specified ports, and, when it receives a

* connection on a port, passes input and output streams to a 

* object which provides the actual service. It can limit the number of

* concurrent connections, and logs activity to a specified stream.

* A main() method for running the server as a standalone program.

* The command-line arguments to the program should be pairs of 

* and port numbers. For each pair, the program will dynamically 

* named Service class, instantiate it, and tell the server to 

* Service on the specified port. The special -control argument 

* followed by a password and port, and will start special server 

* service running on the specified port, protected by the specified

if (args.length < 2) // Check number of arguments

throw new IllegalArgumentException("Must start at least one 

// Create a Server object that uses standard out as its log and

// has a limit of ten concurrent connections at once.

if (args[i].equals("-control")) { // Handle the -control 

s.addService(new Control(s, password), port); // add 

// Otherwise start a named service on the specified port.

// Dynamically load and instantiate a class that 

Class serviceClass = Class.forName(serviceName); // 

Service service = (Service)serviceClass.newInstance(); // 

catch (Exception e) { // Display a message if anything goes wrong

System.err.println("Usage: java Server [-control 

    public void serve(String name, int port)

        throws ClassNotFoundException,

             InstantiationException,

             IllegalAccessException,

Class serviceClass = Class.forName(name); // dynamic load

Service service = (Service) serviceClass.newInstance(); // 

ConnectionManager connectionManager; // The ConnectionManager object

ThreadGroup threadGroup; // The threadgroup for all 

PrintWriter logStream; // Where we send our logging 

* This is the Server() constructor. It must be passed a stream

* to send log output to (may be null), and the limit on the 

* concurrent connections. It creates and starts a ConnectionManager

* thread which enforces this limit on connections.

private void init(OutputStream logStream, int maxConnections) {

connectionManager = new ConnectionManager(threadGroup, 

/** Write the specified string to the log */

protected synchronized void log(String s) {

/** Write the specified object to the log */

protected void log(Object o) { log(o.toString()); }

* This method makes the server start providing a new service.

* It runs the specified Service object on the specified port.

public void addService(Service service, int port) throws 

Integer key = new Integer(port); // the hashtable key

// Check whether a service is already on that port

throw new IllegalArgumentException("Port " + port + " already 

// Create a Listener object to listen for connections on the port

Listener listener = new Listener(threadGroup, port, service);

log("Starting service " + service.getClass().getName() +

* This method makes the server stop providing a service on a port.

* It does not terminate any pending connections to that service, 

* causes the server to stop accepting new connections

Integer key = new Integer(port); // hashtable key

// Look up the Listener object for the port in the hashtable of 

final Listener listener = (Listener) services.get(key);

log("Stopping service " + listener.service.getClass().getName() +

* This nested Thread subclass is a "listener". It listens for 

* on a specified port (using a ServerSocket) and when it gets a 

* request, it calls a method of the ConnectionManager to accept 

* the connection. There is one Listener for each Service being 

* by the Server. The Listener passes the Server object to the

* ConnectionManager, but doesn't do anything with it itself.

ServerSocket listen_socket; // The socket we listen for 

Service service; // The service to provide on that 

boolean stop = false; // Whether we've been asked to stop

* The Listener constructor creates a thread for itself in the 

* threadgroup. It creates a ServerSocket to listen for 

* on the specified port. It arranges for the ServerSocket to be

* interruptible, so that services can be removed from the server.

public Listener(ThreadGroup group, int port, Service service)

// give the socket a non-zero timeout so accept() can be 

/** This is the nice way to get a Listener to stop accepting 

this.interrupt(); // and make the accept() call stop blocking

* A Listener is a Thread, and this is its body.

* Wait for connection requests, accept them, and pass the 

* to the ConnectionManager object of this server

while(!stop) { // loop until we're asked to stop.

connectionManager.addConnection(client, service);

* This nested class manages client connections for the server.

* It maintains a list of current connections and enforces the

* maximum connection limit. It creates a separate thread (one per

* server) that sits around and wait()s to be notify()'d that a 

* has terminated. When this happens, it updates the list of 

public class ConnectionManager extends Thread {

int maxConnections; // The maximum number of allowed connections

Vector connections; // The current list of connections

* Create a ConnectionManager in the specified thread group to 

* the specified maximum connection limit. Make it a daemon 

* the interpreter won't wait around for it to exit.

public ConnectionManager(ThreadGroup group, int maxConnections) {

connections = new Vector(maxConnections);

log("Starting connection manager. Max connections: " + 

* This is the method that Listener objects call when they accept a

* connection from a client. It either creates a Connection object

* for the connection and adds it to the list of current 

* or, if the limit on connections has been reached, it closes the

synchronized void addConnection(Socket s, Service service) {

// If the connection limit has been reached

if (connections.size() >= maxConnections) {

PrintWriter out = new PrintWriter(s.getOutputStream());

// Then tell the client it is being rejected.

"server has reached maximum number of clients.");

// And close the connection to the rejected client.

log("Connection refused to " + s.getInetAddress 

":" + s.getPort() + ": max connections reached.");

else { // Otherwise, if the limit has not been reached

// Create a Connection thread to handle this connection

Connection c = new Connection(s, service);

// Add it to the list of current connections

log("Connected to " + s.getInetAddress().getHostAddress() +

":" + s.getPort() + " on port " + s.getLocalPort() +

" for service " + service.getClass().getName());

// And start the Connection thread running to provide the 

* A Connection object calls this method just before it exits.

* This method uses notify() to tell the ConnectionManager thread

* to wake up and delete the thread that has exited.

public synchronized void endConnection() { this.notify(); }

/** Change the current connection limit */

public synchronized void setMaxConnections(int max) 

* Output the current list of connections to the specified stream.

* This method is used by the Control service defined below.

public synchronized void printConnections(PrintWriter out) {

for(int i = 0; i < connections.size(); i++) {

Connection c = (Connection)connections.elementAt(i);

c.client.getInetAddress().getHostAddress() + ":" +

" FOR SERVICE " + c.service.getClass().getName());

* The ConnectionManager is a thread, and this is the body of that

* thread. While the ConnectionManager methods above are called 

* threads, this method is run in its own thread. The job of 

* is to keep the list of connections up to date by removing 

* that are no longer alive. It uses wait() to block until 

// Check through the list of connections, removing dead ones

log("Connection to " + c.client.getInetAddress 

// Now wait to be notify()'d that a connection has exited

// When we wake up we'll check the list of connections again.

try { synchronized(this) { this.wait(); } }

* This class is a subclass of Thread that handles an individual 

* between a client and a Service provided by this server. 

* such connection has a thread of its own, each Service can have 

* connections pending at once. Despite all the other threads in 

* is the key feature that makes this a multi-threaded server 

Socket client; // The socket to talk to the client through

Service service; // The service being provided to that client

* This constructor just saves some state and calls the superclass

* constructor to create a thread to handle the connection. 

* objects are created by Listener threads. These threads are 

* the server's ThreadGroup, so all Connection threads are part 

public Connection(Socket client, Service service) {

super("Server.Connection:" + client.getInetAddress 

* This is the body of each and every Connection thread.

* All it does is pass the client input and output streams to the

* serve() method of the specified Service object. That method

* is responsible for reading from and writing to those streams to

* provide the actual service. Recall that the Service object 

* passed from the Server.addService() method to a Listener object

* to the ConnectionManager.addConnection() to this Connection 

* and is now finally getting used to provide the service.

* Note that just before this thread exits it calls the

* ConnectionManager.endConnection() method to wake up the

* ConnectionManager thread so that it can remove this Connection

InputStream in = client.getInputStream();

OutputStream out = client.getOutputStream();

finally { connectionManager.endConnection(); }

* Here is the Service interface that we have seen so much of.

* It defines only a single method which is invoked to provide the 

* serve() will be passed an input stream and an output stream to 

* It should do whatever it wants with them, and should close them 

* All connections through the same port to this service share a 

* Service object. Thus, any state local to an individual 

* be stored in local variables within the serve() method. State 

* be global to all connections on the same port should be stored in

* instance variables of the Service class. If the same Service 

* on more than one port, there will typically be different 

* for each port. Data that should be global to all connections 

* Note that implementations of this interface must have a no- 

* constructor if they are to be dynamically instantiated by the 

public void serve(InputStream in, OutputStream out, Logger 

private Logger itsLogger = new Logger() {

* This service is an HTTP mirror, just like the HttpMirror class

* implemented earlier in this chapter. It echos back the client's

public static class HTTPMirror implements Service {

public void serve(InputStream i, OutputStream o, Logger logger) 

BufferedReader in = new BufferedReader(new InputStreamReader(i));

PrintWriter out = new PrintWriter(new OutputStreamWriter(o));

* This service demonstrates how to maintain state across connections

Trying to create a mxj socket listener