多线程共享变量

Question

I have a multi-threading application developed in Java. The new threads fuction is to run network protocols clients and servers.

My problem is in the UDP "thread" to find other instances in the local network and store them in a List. But all the new threads are named threads called by other classes (main thread). So my problem is to get the processed list after the thread is finished.

I have tried to pass the list to constructor parameter and I make the main thread wait for the end of that thread but then the list is empty when it should be with some elements.

Thanks.

EDIT with an example code

public class MainClass{

public static void main(String[] args) {

    List<String> tmp = new ArrayList<>();
    Thread t1 = new Thread(UDPClient(tmp));
    t1.start();
    t1.join();
    //It should be one but it'll be 0
    System.out.println(tmp.size);

}

}

and the separeted class:

public class UDPClient implements Runnable{

private List<String> foundInstances;

public UDPClient(List<String> instances)
{
    foundInstances = instances;
}

public void run()
{
    //do stuff
    foundInstances.add("Hello world");
}
}

it's a simple example...

Answer 1

You can use any of various approaches to communicate between threads. The following sample code illustrates a straightforward one.

import java.util.ArrayList;
import java.util.List;

public class MultiThreaded {

    private static class ListAppender implements Runnable {

        private List<String> strings;
        private String string;

        public ListAppender(List<String> strings, String string) {
            this.strings = strings;
            this.string = string;
        }

        @Override
        public void run() {
            strings.add(string);
        }
    }

    private static class ListConsumer implements Runnable {

        private List<String> strings;

        public ListConsumer(List<String> strings) {
            this.strings = strings;
        }

        @Override
        public void run() {
            for (String s : strings) {
                System.out.println(s);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        List<String> strings = new ArrayList<String>();

        Thread helloThread = new Thread(new ListAppender(strings, "Hello"));
        helloThread.start();
        Thread worldThread = new Thread(new ListAppender(strings, "world!"));
        worldThread.start();

        Thread.sleep(1000);

        new Thread(new ListConsumer(strings)).start();
    }
}

All three threads write to and read from the same list instance. Note that the above approach is not actually thread safe by any measure. You should instead use a thread safe collection class.

The Thread.sleep() allows the ListAppender instances to complete before the ListConsumer is run. Using Thread.sleep() like this is hardly a robust approach, and should probably be avoided in any real world scenario.