Question

I am trying to create a java socket program with multithread concept.
Every single connection from client to the server is a thread.
Every client send their information to server.

I want to ask how to collect all value from the threads and put them all in an array of string?

Is needed to synchronized all this threads?

What the different if use only Thread t = new Thread() instead of Thread[] t = new Thread(client)?

Am i right for the beginning step with use Thread[] to collect all item from the threads?

Is it useful to use thread join()?

This is part which create thread,

    public void listenSocket(int client){ 
        int i=0;

        Thread[] t = new Thread[client];
        while(i<client){
            ClientWorker w;
              try{  
                    w = new ClientWorker(server.accept());
                    t[i] = new Thread(w);
                    t[i].start();
                    System.out.println(t[i].getName());
              } catch (IOException e) {
                    System.out.println("Accept failed: 4444");
                    System.exit(-1);
              }
        i++;
        }
}

This is the part of what the thread doing

class ClientWorker implements Runnable{
    Socket client;
        String ip;
        String load;
        String data[]=new String[7];


        ClientWorker(Socket client){
        this.client = client;
    }

    public void setIP(String ip){
            this.ip = ip;
        }

        public void setData(String load){
            this.load = load;
        }

        public void getIP(){
           System.out.println(ip);
        }

        public void getData(){
           System.out.println(load);
        }

    public void run(){

        BufferedReader in = null;
        PrintWriter out = null;
                XmlGenerator xml = new XmlGenerator();
        try{
          in = new BufferedReader(new InputStreamReader(client.getInputStream()));
          out = new PrintWriter(client.getOutputStream(), true);
        } catch (IOException e) {
          System.out.println("in or out failed");
        }
                while(true){
                    try{
                        String a = in.readLine();
                        setData(a);
                        String b = client.getRemoteSocketAddress().toString();
                        setIP(b);
                        out.println(a);
                        getData();
                        getIP();
                       }
                    catch (IOException e) {
                        System.out.println("Read failed");
                       }
                }

    }

}`

i’ve read the topic about sync,callable thread but i found nothing.
sorry for repost.

Answer 1

There are two ways to answer this:

First way:

I want to ask how to collect all value from the threads and put them all in an array of string? Is needed to synchronized all this threads?

If you are going to collect the results that way, then yes it is necessary to explicitly synchronize the threads’ use of that array.

What the different if use only Thread t = new Thread() instead of Thread[] t = new Thread(client)?

It is not clear what you mean, but either way if you have two threads accessing / updating the same data structure then they need to synchronize for the application to be reliable / portable.

Am i right for the beginning step with use Thread[] to collect all item from the threads?

It is one approach. But there are better approaches.

Is it useful to use thread join()?

If you are going to try to address this problem at this level, then it could be useful.

The problem is that your code doesn’t give me much confidence that you have a clear idea of what you are doing. Or to put it another way, there is no evidence of a design. And it is not really possible to give you specific advice if we can’t figure out how you think your code should work. The code certainly doesn’t seem to line up with the things you are saying at the start of your question …

---

The Second way to answer this is that from Java 5 onwards, the “java.util.concurrent” package provides a broad range of “off the shelf” components for implementing multi-threaded systems. What you seem to be trying to implement sounds like a good match for an ExecutorService. It can deal with all of the low-level details of creating and managing threads, and allows the application to get the results of each computation back via a Future. This takes away the need for explicit synchronization … the ExecutorService and Future implementations take care of that.

So, my recommendation would be to read the Javadocs for ExecutorService, etcetera and figure out how to do what you are trying to do using that. Your code is likely to be better if you do it that way.