Execution order of threads waiting for a synchronized block

advertisements

I have some threads running and all trying to enter the synchronised block.

I have noticed that the thread runs in a random order(when i calls Thread.start()), thats ok

when first Thread executes and enters synchronised method it go to sleep..

during that period others threads comes and start waiting for the synchronised block to get released.

My Question is the last thread came in waiting gets the synchronised block first..

Following is the code.

 import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javax.sql.rowset.Joinable;

public class ThreadOrdering{  public static void main(String... args) {
    Results results = new Results();
    Thread a=   new Thread(new Task(0, "red", results));
    a.start();

    Thread b=  new Thread(new Task(1, "orange", results));
    b.start();

    Thread c=    new Thread(new Task(2, "yellow", results));
    c.start();

    Thread d= new Thread(new Task(3, "green", results));
    d.start();

    Thread e= new Thread(new Task(4, "blue", results));
    e.start();

}
}

class Results {
private List<String> results = new ArrayList<String>();
private int i = 0;

public synchronized void submit(int order, String result) {
     System.out.println("synchronized accupied by: " + order + " " + result);
       try {
        Thread.sleep((long)(Math.random() *1000));
         System.out.println("synchronized released by: " + order + " " + result);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}
}

class Task implements Runnable {
private final int order;
private final String result;
private final Results results;

public Task(int order, String result, Results results) {
    this.order = order;
    this.result = result;
    this.results = results;
}

public void run() {

     System.out.println("run  by: " + order + " " + result);

    results.submit(order, result);

}
}

The sample output is:

run by: 1 orange

synchronized accupied by: 1 orange

run by: 2 yellow

run by: 4 blue

run by: 0 red

run by: 3 green

synchronized released by: 1 orange

synchronized accupied by: 3 green

synchronized released by: 3 green

synchronized accupied by: 0 red

synchronized released by: 0 red

synchronized accupied by: 4 blue

synchronized released by: 4 blue

synchronized accupied by: 2 yellow

synchronized released by: 2 yellow

as we see the order of thread execution is random.. thats ok.. 1 2 4 0 3

so 1 gets the synchronised block and after it ends 3(the last one) gets it then 0 and 4 and 2....

How to make that order reverse,,, that after 1 it must be 2 then 4 then 0 then 3


You should use ReentrantLock if you want fair access to synchronized block.