线程一直在运行，无法停止

Question

I want to make a test, two thread, one thread is changing the value, another thread use a while to wait the first thread, and then break and finish.But the question is the waiting thread is always running, can' stop any more. Another question is when i open the code of "System.out.println(i + " run");", all the thread can work normally, it's so strange.

import java.util.Date;

public class ThreadTestTwo {
    public int a = 0, b = 0,c = 0;

public static void main(String[] args) {
    System.out.println(new Date()+"start");
    for (int i = 0; i < 100000; i++) {
        new ThreadTestTwo().start(i);
        if(i % 100000 == 0){
            System.out.println(i/100000);
        }
    }
    System.out.println(new Date()+"finish");
}

public void start(final int i){
    Thread readThread = new Thread(){
        @Override
        public void run() {
            while (true) {
                if(c == 1){
                    b = a;
//                      System.out.println(i+", set b "+a);
                    break;
                }
//                  System.out.println(i + " run");
            }
        }
    };
    Thread writeThread = new Thread(){
        @Override
        public void run() {
            a = 1;
            c = 1;
        }
    };
    writeThread.setName("mywrite");
    readThread.setName("myread");
    System.out.println(i+" start");
    writeThread.start();
    readThread.start();

    try {
        writeThread.join();
        readThread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(i+" end");
    if(b != 1)
        throw new RuntimeException("b = "+b);
}

}

Answer 1

The writes of one thread are NOT guaranteed to be seen for another thread unless the variables are marked as volatile or otherwise the transactions need to handled using synchronization or explicit locking

In your case, a,b,c are the instance variables accessed by multiple threads and the reader thread caches the values and so it doesn't see the writer thread's flushed value.

Please refer the below link for more details: https://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html

Answer 2

I advise you to read more on Threads. Here it is an interesting document from O'really: http://chimera.labs.oreilly.com/books/1234000001805/ch09.html

As for your implementation, you should be aware that the modification of one variable by a thread may not be seen by a reader thread. To combat that either use synchronised gets and sets, access the variables inside a synchronized block, or use an AtomicReference . You could also use a Lock such as ReantrantLock .

Also, if you have two threads, in which the first is waiting for the input of the second, you could use the wait() inside a synchronized block for the first, so that the second could notify() the first one when it finishes its job.

Something like this:

import java.util.Date;

public class ThreadTestTwo {

    private int a = 0, b = 0,c = 0;
    private final Object lock = new Object(); 
    //Any object is good as a lock, and for a simple case as this it's fine.
     //This object will work as a monitor for the synchronized blocks.

    public void start(final int i){
        Thread readThread = new Thread(){
            @Override
            public void run() {

                synchronized ( lock ) {
                    try {
                        while( c != 1 ) {
                            lock.wait();
                        }
                    }
                    catch ( InterruptedException ex ) {
                        //Exception handling
                    }

                    b = a;
                }

                //System.out.println(i + " run");

            }
        };

        Thread writeThread = new Thread(){
            @Override
            public void run() {

                synchronized ( lock ) {
                    a = 1;
                    c = 1;
                    lock.notify();
                }

            }
        };

        writeThread.setName("mywrite");
        readThread.setName("myread");
        System.out.println(i+" start");
        writeThread.start();
        readThread.start();

        System.out.println(i+" end");
    }

    public static void main(String[] args) {
        System.out.println(new Date()+"start");
        for (int i = 0; i < 100000; i++) {
            new ThreadTestTwo().start(i);
            if(i % 100000 == 0){
                System.out.println(i/100000);
            }
        }
        System.out.println(new Date()+"finish");
    }
}

I would say you don't need join() with this method. But if want to wait for the second thread to start after the first is finished, you have to use join() before starting it. Like this:

    writeThread.start();
    try {
        writeThread.join();
    }
    catch ( InterruptedException ex ) {
        //Exception handling
    }


    readThread.start();
    try {
        readThread.join();
    }
    catch ( InterruptedException ex ) {
        //Exception handling
    }

But if you use join() , for this particular case , I would say you wouldn't need any synchronized blocks or conditions, since the second thread would only start after the death of the first one. Something like this:

public void start(final int i){
    Thread readThread = new Thread(){
        @Override
        public void run() {
            b = a;
            //System.out.println(i + " run");

        }
    };

    Thread writeThread = new Thread(){
        @Override
        public void run() {
            a = 1;
            c = 1;

        }
    };

    writeThread.setName("mywrite");
    readThread.setName("myread");
    System.out.println(i+" start");


    writeThread.start();
    try {
        writeThread.join();
    }
    catch ( InterruptedException ex ) {
        //Exception handling
    }


    readThread.start();
    try {
        readThread.join();
    }
    catch ( InterruptedException ex ) {
        //Exception handling
    }

    System.out.println(i+" end");
}

I hope I have helped.

Have a nice day. :)

Answer 3

It's not a good idea to use an simple int as a signal between threads because it's not thread safe.

So try to use AtomicInteger instead or make your int volatile and see what will happen.