java - 等待同步块(synchronized block)的线程的执行顺序

Question

我有一些线程正在运行，并且所有线程都试图进入同步块(synchronized block)。

我注意到线程以随机顺序运行(当我调用 Thread.start() 时)，没关系

当第一个线程执行并进入同步方法时，它会进入休眠状态。

在此期间，其他线程到来并开始等待同步块(synchronized block)被释放。

我的问题是最后一个等待的线程首先获得同步块(synchronized block)..

以下是代码。

 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);

}
}

示例输出为:

运行者:1个橙子

已同步获得:1个橙色

运行者:2 黄

运行者:4 蓝

运行者:0 红

运行者:3 绿

同步发布者:1个橙色

同步占用:3个绿色

同步发布者:3 green

已同步:0 红

同步发布者:0 red

同步占用:4个蓝色

同步发布者:4 blue

同步获得者:2黄

同步发布者:2 Yellow

我们看到线程执行的顺序是随机的..没关系.. 1 2 4 0 3

所以 1 获取同步块(synchronized block)，结束后 3(最后一个)获取它，然后 0 和 4 和 2....

如何颠倒顺序，，，1之后必须是2然后4然后0然后3

Answer 1

您应该使用ReentrantLock如果你想公平地访问同步块(synchronized block)。