Singleton/Static in Multi threading scenario

[Arpit Purohit]

Hi all,
I have created a class to use singleton Socket to connect to an IP. I want that at a time, only a single thread should be able to use this connection (use its InputStream and OutputStream).
Following is the code:

   
import java.net.Socket;
import java.net.InetSocketAddress;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class MyConnection {
private static Socket socket;
private MyConnection(){}
	public static synchronized void connect(String ip,int port){
		try{
				if(socket!=null){
					if(!socket.isConnected())
					socket.connect(new InetSocketAddress(ip,port));
				}
			else
			socket=new Socket(ip,port);
		}catch(Exception e){
		e.printStackTrace();
                return null;
		}
	}

	public static synchronized InputStream getInputStream(){
		if(socket!=null&&socket.isConnected()){
			try {
				return socket.getInputStream();
			} catch (IOException e) {
			e.printStackTrace();
                        return null;
			}
		}else
		return null;
	}

	public static synchronized OutputStream getOutputStream(){
		if(socket!=null&&socket.isConnected()){
			try {
				return socket.getOutputStream();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}else
		return null;
	}
}/*Not sure if this way to achieve singleton is fine*/

Further I will be using above class as follows:

 
MyConnection.connect(hlrip, hlrport);
is = HLRConnection.getInputStream();
os = HLRConnection.getOutputStream();
/*Do something here with InputStream and OutputStream*/

Now my doubts are:
1. Is above code fine for multi threaded scenario
2. As Socket object is Static(and singleton), will it always return reference to same InputStream and OutputStream (implies they are also singleton).
If Yes than how to make InputStream and OutputStream thread safe.(one way is to use synchronized block in second code snippet)

[Yaroslav Chinskiy]

Hi,

This is not a singleton. Specially if you use Java 1.4
Depending you your need you can do one of the following:

1. For 1.5 you can create an enum that will encapsulate the socket.
2. For 1.4 you can create a handler object that will create singleton (lazy) or define it as a static final variable.
3. Regardless of the pattern you choose to create singleton, abstract in and out streams to synchronized methods that will delegate to IO.
This approach is more flexible in the long run.

[Ashraf Abu-Aisheh]

Yaroslav Chinskiy wrote:Hi,

This is not a singleton. Specially if you use Java 1.4
Depending you your need you can do one of the following:

1. For 1.5 you can create an enum that will encapsulate the socket.
2. For 1.4 you can create a handler object that will create singleton (lazy) or define it as a static final variable.
3. Regardless of the pattern you choose to create singleton, abstract in and out streams to synchronized methods that will delegate to IO.
This approach is more flexible in the long run.

You are appreciated if you modify the above 'Arpit Purohit' code with 1.5 as point #1 and post it again here.

Thanks.

[Yaroslav Chinskiy]

Here is a simple example of singleton socket. The concept is there, implementation may be improved.
I am also putting some simple echo server to test this code.

I hope it makes sense.

   

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public enum SingletonSocket {
    SOCKET;

    private Socket socket;
    private BufferedReader in;
    private BufferedWriter out;
    private IOException exception;

    SingletonSocket() {
        // read configuration from file/preferences or other sources.
        // for now I assume that config is strorred in environment.
        String host = System.getProperty("MyConnection.host", "localhost");
        int port = Integer.parseInt(System.getProperty("MyConnection.port", "1600"));
        try {
            socket = new Socket(host, port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        } catch (IOException e) {
            exception = e;    // record state
        }
    }

    public IOException getException() {
        return exception;
    }

    public boolean isConnected() {
        return socket != null && socket.isConnected();
    }

    public void close() throws IOException {
        if (socket != null)
            socket.close();
    }

    public String readLine() throws IOException {
        if (!isConnected()) {throw new IllegalStateException("Socket is not connected."); }
        return in.readLine();
    }

    public void writeLine(String line) throws IOException {
        if (!isConnected()) {throw new IllegalStateException("Socket is not connected."); }
        synchronized (out) {
            out.write(line);
            out.newLine();
            out.flush();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        for (int j = 0; j < 1000; j++) {
                            SOCKET.writeLine("" + Thread.currentThread() + j);
                            System.out.println("<" + SOCKET.readLine() + ">");
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class EchoServer implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService executors = Executors.newFixedThreadPool(10);

    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(1600, 100);
    }

    public void run() {
        while (true) {
            final Socket client;
            try {
                client = serverSocket.accept();
                executors.execute(new Runnable() {
                    public void run() {
                        BufferedReader reader = null;
                        BufferedWriter writer = null;
                        try {
                            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
                            writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
                            String line;
                            do {
                                line = reader.readLine();
                                writer.write("-> " + line);
                                writer.newLine();
                                writer.flush();
                            } while (!line.startsWith("QUIT"));
                        } catch (IOException e) {
                            e.printStackTrace();
                        } finally {
                            if (reader != null) {
                                try {
                                    reader.close();
                                } catch (IOException e1) {}
                            }

                            if (writer != null) {
                                try {
                                    reader.close();
                                } catch (IOException e1) {}
                            }
                        }
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        EchoServer server = new EchoServer();
        server.run();
    }
}


 

[Ashraf Abu-Aisheh]

many thanks to you

Yaroslav Chinskiy