使用侦听器的怪异Java并发问题

Question

I'm currently learning concurrency in java and I just wondered if java listeners would be thread safe, so I wrote this up. I've come across a really odd issue where if println is commented out, the program will never exit. Am i not making something synchronized when i should?

Any ideas?

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class MainComponent implements MainThreadListener
{
    private static final int THREADS = 10;
    int notifsOld;
    int notifs;

    public MainComponent()
    {
        notifs = 0;
        notifsOld=0;
    }

    public void start()
    {
        dispatch();
        loop();
    }
    public void dispatch()
    {
        /*  start 10 threads
         *  the lewThread starts, sleeps for (0-10 secs)
         *  and then notifies the MainComponents implemented listener */

          for (int i = 0; i <= THREADS; i++) {
            new LewThread(this).start();
        }
    }

    public void loop()
    {
        while(notifs < THREADS)
        {
            /* when println is commented out, the program will never end. ??? */
            //System.out.println(notifs);
            if(notifs != notifsOld)
            {
                /* this only runs once at the end */
                notifsOld = notifs;
                System.out.println("notifs changed");
            }
        }
    }

    @Override
    public void threadNotified(){notifs++;}

    public static void main(String... args)
    {
        new MainComponent().start();
    }

}

Answer 1

Just try to synchronize you threadNotified method :

public synchronized void threadNotified(){notifs++;}

this will ensure no 2 threads will increment notifs at the same time, which would result in a single increment. You should probably also synchronize all access to the variables.

I think a simpler alternative would be mark the notifs variable as volatile :

volatile int notifsOld;
volatile int notifs;

Usually, in java, each thread gets its own local copy of each variables. Volatile ensures that all those copies are synchronized before being red or written. So all threads act on the same values of the variables.

Answer 2

It looks like you have run into the classic "Performance Testing" issue of JIT languages. JIT (Just In Time) compilers will only compile code paths which have an observable output. When you comment out the Println, the code no longer does anything, so the compiler optimises the entire code branch away.

Most likely the entire code branch loop() is optimised away, and only dispatch runs. You can try using eclipses "step over" command in debug to see if it actually runs loop. Alternatively, try putting "println(notifs + " " + notifsOld") after loop(); this should make the notifs updates important again.

Also, you should make Notifs (atomic and volatile) or synchronized, but I don't really think that is the problem here.