Java线程：等待，notifyAll和同步的关键字无法按预期工作

Question

Current Status: (Oct 10,2013): Solved.

Problem: I was studying the threads and decided to implement some assignment randomly. So Google one and found this assignment

Description (Eliminating the game logic, main aim is to focus on the threads) I have four players sitting in a circle, Cards have been divided between them. They will shuffle the their deck of cards (This task is for simplicity, obviously game logic is different), once all are done with their cards they can raise hands that they are done and then all can repeat the process, In technical terms threads will wait for others to finish and then whoever reaching or finishing last can notify others to continue...

My code status:

1. Different threads are entering in synchronized block at same time.
2. Once a thread completes his work, it should increment the count variable and count=4 current thread should notify the 3 other waiting for, ultimately I want to achieve happens-before relationship.

Main Class:

   public class RunGame implements Runnable{

    volatile int count=0;
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    public static void main(String arg[]){

    RunGame obj= new RunGame();

    Player p1= new Player("Player 1");
    Player p2= new Player("Player 2");
    Player p3= new Player("Player 3");
    Player p4= new Player("Player 4");

    Runnable r1 = new ThreadRun(p1,obj);
    Runnable r2 = new ThreadRun(p2,obj);
    Runnable r3 = new ThreadRun(p3,obj);
    Runnable r4 = new ThreadRun(p4,obj);

    Thread t1 = new Thread(r1,"Player 1");
    Thread t2 = new Thread(r2,"Player 2");
    Thread t3 = new Thread(r3,"Player 3");
    Thread t4 = new Thread(r4,"Player 4");


    t1.start();
    t2.start();
    t3.start();
    t4.start();
    }
    }

Model:

  public class Player {
    private String player;

    public Player(String name) {
        this.player=name;
    }

    //getter and setter
}

Business Class:

    public class PlayerRun implements Runnable{

        Player player;

    RunGame mainObj;
    public PlayerRun(Player player,RunGame main) {
        this.player=player;
        this.mainObj=main;
    }

    public void run() {
        while(true){
        synchronized (mainObj) {
            int count=mainObj.getCount();
            System.out.println(Thread.currentThread().getName()+"...."+count);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            mainObj.setCount(++count);
            System.out.println(Thread.currentThread().getName()+" Done...."+count);
        }

        synchronized (mainObj) {
            try {
                if(mainObj.getCount()<=3)
                    mainObj.wait();//current thread will wait till it is awaken by notify.
                else if(mainObj.getCount()>3){
                    System.out.println(Thread.currentThread().getName()+" is last one to enter and awake all");
                    mainObj.setCount(0);
                    mainObj.notifyAll();
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"==============================");

        }
    }}

Output:

    Player 1....0
Player 1 Done....1
Player 4....1
Player 4 Done....2
Player 3....2
Player 3 Done....3
Player 2....3
Player 2 Done....4
Player 2 is last one to enter and awake all
Player 2==============================
Player 2....0
Player 3==============================
Player 4==============================
Player 2 Done....1
Player 1==============================
Player 4....1
Player 4 Done....2
Player 3....2
Player 3 Done....3
Player 1....3
Player 1 Done....4
Player 1 is last one to enter and awake all
Player 1==============================
Player 3==============================
Player 1....0
Player 1 Done....1
Player 4==============================
Player 3....1
Player 2==============================
Player 3 Done....2
Player 2....2
Player 2 Done....3
Player 4....3
Player 4 Done....4
Player 4 is last one to enter and awake all
Player 4==============================
Player 4....0
Player 3==============================
Player 2==============================
Player 4 Done....1
Player 1==============================
Player 2....1
Player 2 Done....2
Player 3....2
Player 3 Done....3
Player 1....3
Player 1 Done....4
Player 1 is last one to enter and awake all
Player 1==============================
Player 3==============================
Player 1....0
Player 1 Done....1
Player 2==============================
Player 4==============================
Player 3....1
Player 3 Done....2
Player 4....2
Player 4 Done....3
Player 2....3
Player 2 Done....4
Player 2 is last one to enter and awake all
Player 2==============================
Player 3==============================
Player 2....0
Player 1==============================
Player 4==============================
Player 2 Done....1
Player 4....1
Player 4 Done....2
Player 1....2
Player 1 Done....3
Player 3....3
Player 3 Done....4
Player 3 is last one to enter and awake all
Player 3==============================
Player 3....0
Player 1==============================
Player 3 Done....1
Player 4==============================
Player 1....1
Player 2==============================
Player 1 Done....2
Player 2....2
Player 2 Done....3
Player 4....3
Player 4 Done....4
Player 4 is last one to enter and awake all
Player 4==============================
Player 2==============================
Player 3==============================
Player 1==============================
Player 4....0
Player 4 Done....1
Player 1....1
Player 1 Done....2
Player 3....2
Player 3 Done....3
Player 2....3
Player 2 Done....4
Player 2 is last one to enter and awake all

Answer 1

Your synchronize block takes separate lock for each player so locking is bound to fail. See this:

synchronized (this) {

                try {

                System.out.println(Thread.currentThread().getName()+" work in progress..."+count);
                for(int i =0;i<=3;i++){
                    Thread.sleep(1000);
                }
                count++;
                System.out.println(Thread.currentThread().getName()+" work Done..."+count);

} All the players should take lock on same object.

So you can create a common lock for all players and pass it down to PlayerRun to resolve this issue.

EDIT:

As per below comments user requirements is

" If I understand it correctly he wants the players to do their work (simultaneously) then everyone who's finished waits until the last one is done with his work and they begin again."

This adds a completely new dimension tot he question. The approach taken of synchronized block is incorrect in this case as it will mean mutually exclusive approach. You should use CyclicBarrier , a single barrier for all threads and you can achieve this.

Answer 2

1. Different threads are entering in synchronized block at same time.

The synchronization mechanism is used to have coordinated access to shared variables in a multi threaded environment. Whenever more than one thread accesses a given state variable, and one of them must write to it, they all must coordinate their access to it using synchronization.

You are using synchronized(this) in the run method of the PlayerRun class, which says that only one thread of execution can execute this block of code at any given point in time. As you have created 4 PlayerRun instances and started them to run independently of each other, so they are entering their own synchronized blocks at the same time.

Again you have defined your count variable as static:

static volatile int count=0;

you need to use the runtime class of PlayerRun as the monitor, because it is not tied to any specific instance of PlayerRun . So the changes of the count variable should be synchronized on PlayerRun.class :

synchronized(PlayerRun.class)
{  
   count++;  
} 

Once a thread completes his work, it should increment the count variable and count=4 current thread should notify the 3 other waiting for, ultimately I want to achieve happens-before relationship.

The methods wait, notify and notifyAll gives a group of threads a way to wait for a specific condition to become true (these all are instance methods). When you use wait on some object, it means the current thread of execution will wait for some condition to become true for this object. Whereas notify and notifyAll are used to notify other threads waiting on the same object. These set of methods are used when multiple threads are working with the same object and the way you have written your code is different from this approach.

My suggestion is to use one shared counter among all the threads. This you can achieve by defining a count variable in the RunGame class and pass an instance of this to PlayerRun runnables:

public class RunGame implements Runnable{

private int count=0;
...
public synchronized void increaseCount() throws InterruptedException {
      count++;
}
....
@Override
public void run() {
Runnable r1 = new PlayerRun(player1, this);
...
}
}

You can change the PlayerRun as this:

public class PlayerRun implements Runnable{
    RunGame runGame;
    ...
    public PlayerRun(Player player, RunGame runGame) {
        this.player = player;
        this.runGame = runGame; 
    }
    ...
    @Override
    public void run() {
    // DO YOUR WORK
    runGame.increaseCount();
    }
}

Answer 3

Actually Every thread will update the count on its turn, so after count 3 it will become 3, when 4th thread would enters it will increment it to 4 and notify all others to repeat the process.

The above statement is copied from your comment . And I think this changes the requirement that was there initially, as now you want to repeat the process all over again. For this, you need to replace the increaseCount method with two methods, one to make the threads wait if the count < 4 and the other is to notify the waiting threads when the count becomes 4:

   //threads will increment the value of count by 1 and will wait if its value is
   //less than 4.
   public synchronized void increaseCount() throws InterruptedException {
        count++;
        if (count < 4) {
            wait();
        }
    }

    //4th thread will come inside this method, it will set the count value to 0
    //and will notify other threads
    public synchronized void releaseCount() throws InterruptedException {
        if (count >= 3) {
            count = 0;
            notifyAll();
        }

    }

And change the PlayerRun as this:

public class PlayerRun implements Runnable{
    RunGame runGame;
    ...
    public PlayerRun(Player player, RunGame runGame) {
        this.player = player;
        this.runGame = runGame; 
    }
    ...
    @Override
    public void run() {
    while (true) {
    // DO YOUR WORK
    runGame.releaseCount();
    runGame.increaseCount();
    }
    }
}

You don't need to use synchronized keyword inside the run method of PlayerRun . The synchronized keyword is used to coordinate access to shared variables. You have your shared variable count in RunGame , to which you can provide synchronized access by using synchronized keyword on increaseCount and relaesCount .