Full-duplex server socket implementaion, seperate read and write thread?

Question

I want to read and write(randomly from server to client) on same server socket (java application). My client to server write and read work fine in a loop. At server with response write properly.

But if i am trying to write at server randomly some command. i do not have solution, first of all my question is :

1. is it possible at server side to write command to client ramdonly on same socket?
2. if possible, any suggestion or pointer how to do it?
3. please give me some pointer where I can read the material about this scenario ?

thanks in advance.

public class ContentServerSocket extends ServerSocket {
    private final static int PORT = 4444;

    protected static boolean XYZGONE = false;
    public static Content content;

    public ContentServerSocket(xyzService service) throws IOException {
        super(PORT);

        while (true) {

            Log.d(TAG, "Waiting for new request from client(content) ....");
            new HandleRequest(accept(), service).start();
        }
    }

    public static void xyzRunAway() {
        Log.d(TAG," Content Serv er 1 ");
        XYZGONE = true;
    }

}

class HandleRequest extends Thread {
    private final static String TAG = "ContentServerSocket:Thread for a request:";
    private Socket client;
    private xyzService service;

    private static  Context context;

    HandleRequest(Socket client, SuggestionService service) {
        this.client = client;
        this.service = service;
        context = xyzService.serviceContext();  
    }

    public void run() {
        while (true) {
            try {

                Log.d(TAG, " Step 1: client: Received request  MSG for Check...  ");
                PrintWriter out = new PrintWriter(client.getOutputStream(),
                        true);

                BufferedReader in = new BufferedReader(new InputStreamReader(
                        client.getInputStream(), "utf-8"));
                String request = "";
                String tmpLine = null;


                Log.d(TAG, " Step Xyz waiting data from the client ...  ");


                while ((tmpLine = in.readLine()) != null) {

                    if (tmpLine.length() > 0) {
                        request += tmpLine;
                        //if (tmpLine.toLowerCase().contains("</contentInfo>")) {
                        if (tmpLine.contains("</contentInfo>")) {
                            Log.d(TAG, " Server : broke because of </contentInfo>");
                            break;
                        }
                    } else {
                        Log.d(TAG, " Step NULL :   ");
                        request = "";
                    }

                } 



                Log.d("Robin", " Step 2: Actual request received from the client : : " + request);
                if (request.length() == 0) {
                    Log.d("Robin",
                            " client got 0 length request, thread stop!");
                    throw new Exception();

                }
                //XMLParser xmlParser = new XMLParser(new ByteArrayInputStream(
                //      request.getBytes("UTF-8")));

                Log.d(TAG, " Step 3 :   ");
                RequestParser readxmlrequest = new RequestParser(request);
                String requestType = readxmlrequest.parsingXmlRequestFromContent();
                Log.d(TAG, " Step 4  requestType :   " + requestType);


                //TODO : need to get the result and pas to the out.println..

                //String result = processXML(xmlParser);

                String result = responseToContentRequest(readxmlrequest,requestType);//null; //TODO need to complete.
                Log.d(TAG, " Step 5 result :   "+result);
                 (((((((((())))))))))";
                if (result != null && result.length() > 0) {

                    //oos.writeObject(result);
                    Log.d("Robin", " Writing response to socket ... ");
                    out.println(result + "\n");
                    out.flush();
                    Log.d("Robin", " Writing flush completed ");
                }

                if(ContentServerSocket.XYZGONE) {
                    Log.d(TAG," XYZGONE >>>>>>>> ");
                    ContentServerSocket.XYZGONE = false;
                    String tmp = "<ssr> OK Done .......</ssr>";
                    out.println(tmp + "\n");
                    Log.d("Content Server Socket ", "xyz:" + tmp);
                    out.flush();
                }

            } catch (IOException ioException) {
                Log.d("Robin", " IOException on socket listen: " + ioException);
            }
            catch (Exception e) {
                Log.d("Robin", " outer exception: " + e.toString());
                break;
            }

            finally {
                if (client == null || client.isClosed()
                        || !client.isConnected()) {
                    Log.d(" Robin ", " client is null");
                    break;
                }
            }
            //break;

            }
        Log.d("Robin", " thread stop... ");
    }

Answer 1

So , I fixed it . I just need to maintain two different thread. 1) read. 2)write.

In the above code i just started one more thread for write .

insert the code in Run function of above code.

====================================================

Runnable r1 = new Runnable() {
    public void run() {
            try {
            while (true) {
                System.out.println("Hello, world!");
                if(ContentServerSocket.XYZGONE) {
                    Log.d(TAG," XYZGONEY >>>>>>>> ");
                    ContentServerSocket.XYZGONE = false;
                    String tmp = "<ssr> OK Done .......</ssr>";
                    out.println(tmp + "\n");
                    Log.d("Content Server Socket ", "XYZGONE :" + tmp);
                    out.flush();
                }
                Thread.sleep(1000L);
            }
        } catch (InterruptedException iex) {}
    }
};

Thread thr1 = new Thread(r1);

==================================

Then Start the thread in the wile loop of read. with the following code with a check.

====================================

if(!thr1.isAlive())thr1.start();

Thanks everyone, who respond my question..

Answer 2

Yes it is possible to write data from multiple threads on a server or on a client to an existing socket. However you have to make sure the requests do not overlap, and the receiving side actually knows what is written from who.

If you use a line based protocol you can define each message is a single line. In that case you should synchronize multiple threads in a way that only one is writing parts of that line at any given moment.

Your code is a bit too big to understand where your problem is, sorry.

Maybe this tutorial helps? There are quite many out there:

http://www.javaworld.com/javaworld/jw-12-1996/jw-12-sockets.html