两个线程之间的静态值共享Java

Question

I have two different subprocess running two different commands in two different threads.the second thread updates a value in a static variable and the first thread takes the value and uses it.

The flow should be like this : Thread2 updates static variable and thread1 takes up the value from the static variable and then prints it.. but the flow that's happening is thread1 picks up the value from the static variable first. In this case it has a null value and then thread2 updates the value.

Both the threads are running in parallel, i am using ExecutorService class to do this. I'm using Runtime class to run the command and a while loop to read the outputs from the Stream continiously on both threads.

Thread1 keeps on giving (X,Y) values , Thread two gives out the value only when it gets a text.

Output I'm getting :

(12, 123) null --> thread2 didn't get any value so it doesnt update, thread1 would get null from the static variable
(123,334) null --> thread1 picks up the value from the static variable and uses it, thread2 then updates value "Hello" to static variable
(134,654) "Hello" --> thread1 picks up "Hello" and uses it, thread2 then updates value "World" to static variable

Expected output:

(12, 123) null --> thread2 didn't get any value so it doesnt update, thread1 would get null from the static variable
(123,334) "Hello" --> thread2 updates value "Hello" to static variable, thread1 picks it up and uses it
(134,654) "World" --> thread2 updates value "World" to static variable, thread1 picks it up and uses it

i've used a volatile variable too but the output didn'y change. I'm i missing something here? Please help...

Answer 1

You can use java.util.concurrent.Semaphore(as of Java 5) to control the number of threads simultaneously accessing a variable they have in common.You instantiate this class with the number of threads(which have called acquire()) allowed to use what they have in common and if you pass 0, it means none of them can modify it.

public class Threaad extends Thread{
volatile static String string;
public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(0);
    Thread writer = new Write(semaphore);
    writer.setName("writer");
    Thread reader = new Read(semaphore);
    reader.setName("reader");
    ExecutorService service = Executors.newCachedThreadPool();
    service.execute(writer);
    service.execute(reader);
    service.shutdown();
}
}
class Write extends Thread{
    private Semaphore semaphore;
    Write(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Threaad.string = String.valueOf(i);
            semaphore.release();
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Read extends Thread{
    private Semaphore semaphore;
    Read(Semaphore semaphore){
        this.semaphore = semaphore;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                semaphore.acquire();
                System.out.println(Threaad.string);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 2

Things not to do when using threads: writing and reading the same variable without proper synchronization. You violate this rule and therefore you run into the expected problems of undefined results.

Imagine the following execution flow:

T1: set var to "Hello"
T2: checks var and notices it is a String, proceeds to print it.
T1: set var to null
T2: prints var. (which is already null again)

A possible solution is that T2 first copies the value to a thread-local variable and then proceeds working on that one, iE:

while (running) {
  final String localString = staticString;
  if (localString != null) {
    System.out.println(localString);
  }
}

This way you create a "snapshot" of the current value of the variable, and will actually output what has been snapshotted at that moment. However this still is no valid way to synchronize between threads, because the snapshot state is completely random. Imagine that the following happens:

T1: set var to "hello"
T1: set var to null
T2: checks var, it is null, do nothing.
T1: set var to "world"
T1: set var to null
T2: checks var, it is null, do nothing.

When working with Threads you need to keep in mind that the state of any thread at any time is always undefined, unless you enforce it.

There are simple ways to enforce a specific state iE synchronized which basically means "Put the whole thing on hold so I can do my work", however that is quiet inefficient, as there is no point of working in parallel if you constantly put everything on hold.

A much better way to approach Threading is from an architectural point of view iE by using triggers. In your case the writer-thread could have a queue with only relevant information (the strings to output), and the producer-thread will put strings into that queue:

T2: checks queue, it is empty, do nothing.
T1: t1.put("Hello")
T2: checks queue, it contains "Hello", print that.
T2: checks queue, it is empty, do nothing.
T2: checks queue, it is empty, do nothing.
T1: t1.put("World")
T2: checks queue, it contains "World", print that.

I recommend to read through the concurrent package to learn about the tools Java offers. Almost all problems can be easily solved using those.