0

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

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

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

在此期间，其他线程开始等待同步块被释放。

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

以下是代码。

 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绿

同步占用：0红色

同步发布者：0 red

同步占用：4蓝

同步发布者：4 blue

同步占用：2 黄色

同步发布者：2 黄色

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

所以 1 得到同步块，在它结束后 3（最后一个）得到它，然后 0 和 4 和 2....

如何使该顺序反转，，，在1之后它必须是2然后4然后0然后3

4

2 回答 2

4

如果你想公平访问同步块，你应该使用ReentrantLock 。

于 2015-06-11T16:33:09.527 回答
1

我的问题是最后一个等待的线程首先获得同步块？

简短的回答是不。

多线程机制不提供这种管理唤醒顺序的能力。这取决于许多因素，哪个线程被唤醒以及以什么顺序唤醒。您必须手动管理它。创建一些共享变量或堆栈，如果线程还不能工作 - 大喊它并等到下一次它有控制权。然后再做一次，直到时间/顺序正确。

于 2015-06-11T17:06:11.857 回答