了解java多线程中的公平锁
在Java多线程中，公平锁是一种保证线程获取锁的顺序与其请求锁的顺序相同的锁。公平锁的实现方式是通过维护一个等待队列，当一个线程请求锁时，如果锁已经被其他线程占用，则该线程会被放入等待队列中，按照先进先出的顺序等待获取锁。
公平锁的优势在于公平性，它能够避免线程饥饿现象的发生，即某些线程一直无法获取到锁的情况。公平锁能够保证所有线程都有机会获取到锁，公平性是相对于非公平锁而言的。
公平锁适用于对锁的获取顺序有严格要求的场景，例如任务调度、消息队列等。在这些场景下，公平锁能够保证任务或消息的处理顺序与其到达的顺序一致，避免数据竞争和不确定性。
腾讯云提供了一系列与Java多线程相关的产品和服务，其中包括云服务器、容器服务、函数计算等。这些产品可以帮助开发者在云环境中部署和管理Java多线程应用，提供高可用性和弹性扩展的支持。
以下是腾讯云相关产品和产品介绍链接地址：
- 云服务器（Elastic Compute Cloud，简称CVM）：提供可扩展的计算能力，支持在云上运行Java多线程应用。了解更多：https://cloud.tencent.com/product/cvm
- 容器服务（Tencent Kubernetes Engine，简称TKE）：基于Kubernetes的容器管理服务，可以帮助开发者快速部署和管理Java多线程应用。了解更多：https://cloud.tencent.com/product/tke
- 函数计算（Serverless Cloud Function，简称SCF）：无需管理服务器的事件驱动计算服务，可以用于处理Java多线程任务。了解更多：https://cloud.tencent.com/product/scf
请注意，以上仅为腾讯云提供的一些相关产品，其他云计算品牌商也提供类似的产品和服务。
相关·内容
1回答
为了防止java中的饥饿，使用锁而不是声明同步函数时，不能实例化锁类型
它是否需要像上面的FairLock那样实现 do java的锁相等的FairLock？它说FairLock会降低性能，在实际操作中会是什么？
锁=新锁()；
浏览 3提问于2012-10-25得票数 1
回答已采纳
1回答
我扫描了synchronized语句上的所有java synchronized，找出了这个问题的答案，没有结果。
假设我有thread1、thread2、thread3试图同时运行以下代码。
synchronized(lockObj) {
doSomething();
}
假设thread1先到doSomething()，然后是thread2，然后是thread3，它将阻塞和等待synchronized语句。
问题
当thread1释放锁时，哪个线程将首先被释放？
在释放锁时应用的一般顺序规则是什么？
浏览 1提问于2012-06-30得票数 11
回答已采纳
1回答
Java增量基准
、、、
我研究了多线程增量的最佳性能。我检查了基于同步、AtomicInteger和自定义实现的实现，比如在AtomicInteger中，但是在失败的parkNanos(1)上。
private int customAtomic() {
int ret;
for (;;) {
ret = intValue;
if (unsafe.compareAndSwapInt(this, offsetIntValue, ret, ++ret)) {
break;
}
浏览 3提问于2015-11-01得票数 7
2回答
ReentrantLock使用什么样的机制？我正在努力弄清楚它在Java飞行记录下会出现在哪里。我的期望是锁将在Java等待部分下，但情况似乎并非如此。
背景：
我试图通过捕获java飞行记录来调试有问题的ReentrantLock。锁本身非常简单：
public class SomeClass {
private final ReentrantLock lock = new ReentrantLock();
public void capture() {
boolean exclusive = someFunction();
try {
if (ex
浏览 0提问于2021-06-20得票数 0
回答已采纳
2回答
我在浏览可重入锁的Java时发现了以下文本：
锁的公平性不能保证线程调度的公平性。因此，使用公平锁的多个线程中的一个可以连续多次获得该锁，而其他活动线程则没有进展，目前也没有保存该锁。
根据我的理解，如果OS调度程序调度相同的线程(之前获取锁)，并且再次尝试获取相同的锁，Java将允许它获取并且不服从公平参数值。有人能告诉我公平参数的目的是什么吗?在什么情况下应该使用它。
我只是在想，如果它只是一个优先级值，这可能会影响调度程序，但不能保证线程执行顺序。
浏览 0提问于2021-12-03得票数 0
回答已采纳
1回答
我想问您一个与Java多线程有关的问题。
我有一个监视器，多个线程都渴望拥有它。另外，在关键部分中，this.wait()也是根据某些条件调用的。
AFAIK，监视器有2组线程：
入口集-刚刚到达的线程聚集并等待轮到他们拥有监视器。
等待设置-等待唤醒的this.wait()线程
但是当notify/notifyAll被调用时，它们是如何竞争的呢？等待集中的线程在获取监视器时是否优先于条目集中的线程，或者它们是否移动到条目集？
我能否确保在notify的情况下，下一个执行的线程将是一个来自等待集的线程？
浏览 0提问于2019-06-27得票数 4
下面是一些我最近问过受访者的问题，他们说他们知道Java并发性：
解释“内存可见性”的危险-- JVM可以重新排序对不受监视器保护且未声明的volatile的变量的某些操作，这样一个线程可能看不到另一个线程所做的更改。通常，我通过显示代码来问这个问题(例如，Goetz等人在清单3.1中的清单3.1中的“”中的NoVisibility示例)，并询问出了什么问题。
解释volatile如何不仅影响声明为volatile的实际变量，而且影响线程在更改volatile变量之前对变量所做的任何更改。
为什么要使用volatile而不是synchronized呢？
用wait()和notifyAll()实
浏览 0提问于2012-12-07得票数 12
回答已采纳
1回答
公平保证FIFO调度吗？
、、、
直接从这个
但是，如果在创建新的ReentrantLock对象时将公平性参数指定为“true”，则可以保证等待时间最长的线程接下来将获得锁。听起来很不错，对吧？
我认为它从来没有得到保证，它只是影响调度程序的决定。是不是上面链接的网站实际上是在说真话？
提前谢谢。
浏览 3提问于2013-07-23得票数 1
回答已采纳
1回答
假设我有这个方法
/*1*/ public synchronized void method1() throws InterruptedException {
while (condition)
/*2*/ wait();
/*3*/ notify();
}
假设在第2行等待条件下有一个Thread 1，所以线程1将处于状态WAITING。
现在Thread 2进入，它不满足条件，所以它绕过while循环，然后Thread 2在第3行调用notify，然后Thread 1应该将其状态从WAITING更改
浏览 0提问于2021-07-09得票数 0
回答已采纳
在这种情况下，多个线程将通过调用来轮询单个。我想知道的是：
如果多个线程正在等待队列接收一个项，那么它们是按照调用take()的顺序将项目从队列中删除，还是线程从队列中取出东西的顺序是任意的？
谢谢!
注意:我曾经为这类事情编写过自己的实现，但我想知道BlockingQueue实现是否会为我做到这一点。
浏览 4提问于2013-08-27得票数 6
回答已采纳
与Java中的同步块相比，新的Lock接口有什么优势？你需要实现一个高性能的缓存，它允许多个读取器但单个写入器保持完整性，你将如何实现它？
浏览 0提问于2011-11-06得票数 8
2回答
服务器端同步块
、、、
我希望服务器一次为一个客户端执行服务的某一部分强制代码，线程安全；然后依次执行。以下是服务器端服务实现中执行以下操作的部分：
public BorcData getBorcData(String userId) throws GeneralException, EyeksGwtException
{
StoredProcedure sp = DALDB.storedProcedure("BORCBILDIRIM_GETMUKDATA_SP");
DALResult spResult;
Row spRow;
Stri
浏览 1提问于2013-11-11得票数 1
回答已采纳
1回答
我遇到了Writer线程在没有获得锁的情况下被饥饿的问题。请看下面的代码。如果我试图使用读锁的tryLock()来获取锁，写进程将会变得饥饿，并且它将永远无法写入。即使在公平的情况下，编写器进程也会完全饿死，永远不会执行。相反，如果我只尝试reader.readLock()，那么写入器进程将能够获得锁。
请一定要让我知道，如果我错过了什么，写入器进程线程，即使它设置为高优先级，它永远不会获得锁，并将卡住等待锁。
谁能告诉我，我是否可以在ReadWriteLocks中使用trylock()。
import java.util.concurrent.ExecutorService;
import
浏览 4提问于2017-07-15得票数 0
我读过关于线程交错和Java线程调度的帖子，但是我不明白为什么我的两个简单的Java线程在一个独占的资源上运行，在某种程度上不能获得对该资源的交错访问。
在下面的代码中，我有一个Resource类，它唯一的static access()方法包含一个同步块。我只需在main中创建并启动两个MyThread实例，每个线程循环重复调用Resource.access()。每次访问都会休眠1秒，然后释放资源。
public class X {
public static void main(String[] args) {
System.out.println("Crea
浏览 0提问于2020-09-05得票数 3
我的问题是：
让我们说，我有类A和一些变量a
和带有变量B和next的类
在类A中，我希望使方法changeIfEqual(B myB)检查A.a == my_B.prev，如果是，则将A.a更改为my_B.next。但是，如果是A.a != my_B.prev，我希望线程到wait()，直到恢复为真为止，然后执行线程，这个线程已经运行了很长的时间。
所以我认为A.changeIfEqual(B myB)应该是这样的：
public synchronized void changeIfEqual(B myB){
while(this.a != myB.b_prev){
wait(
浏览 0提问于2019-11-12得票数 2
回答已采纳
当AutoResetEvent在进程1上调用WaitOne，并在Process2中再次调用它，而进程2在同一个AutoResetEvent上调用设置时，它不应该释放Process1上的锁，就像在进程2中的锁之前被调用一样吗？
我有一个用来执行进程1和进程2的示例代码，我不带任何参数运行进程1，所以它在wh.WaitOne()挂起。我使用一个参数运行进程2，所以它调用Set()我观察到的是进程2的锁被释放，而不是进程1的锁被释放。
AutoResetEvent的锁队列是否应该表现为先进先出？
class ThreadSafe
{
static EventWaitHandle wh = n
浏览 1提问于2009-09-30得票数 1
回答已采纳
2回答
Java锁解释
、、
我无法理解以下代码：
public class Counter {
private long value;
private Lock lock;
public long getAndIncrement() {
lock.lock();
try {
int temp = value;
value = value + 1;
} finally {
lock.unlock();
}
return temp;
}
}
我无
浏览 0提问于2017-03-25得票数 1
回答已采纳
我对tryLock和lock.tryLock(超时值，单位)的ReentrantLock功能没有什么疑问。
如果两个线程正在通过调用lock.tryLock(超时值，单元).And锁等待锁，而两个线程仍在等待(它们的超时时间尚未完成)，.My问题是哪个线程将被锁定？还有另一个等待线程会发生什么呢？
示例：
在t=0 th1拥有锁
在t=1，th2调用lock.tryLock(超时，单位)4秒
在t=2，th3调用lock.tryLock(超时，单位)3秒
在t=3，th1释放了锁
我认为如果锁是公平的，th2会得到锁。我是对的？
如果锁不是fair.and，那么会发生什么呢?另一个线程会发
浏览 1提问于2017-03-14得票数 0
2回答
Anderson等人(1990)描述了一种教学上简单的自旋锁，它使用长度N的数组来实现用于互斥的FIFO机制。在Herlihy等人的“多处理器编程艺术”第7.5.1节中。(第二版，2020年)，该锁的实现方式如下(逐字摘自该书)：
public class ALock {
ThreadLocal<Integer> mySlotIndex = new ThreadLocal<>() {
@Override protected Integer initialValue() { return 0; }
};
AtomicInteger
浏览 15提问于2022-10-15得票数 0
回答已采纳
我是高级Java和学习重入锁的新手。我理解ReentrantLock有一个公平的参数，它确保锁被分配给大多数饥饿的线程(与同步内部锁中的情况不同)。
但是，可重入也意味着同一个线程可以通过增量holdCount一次又一次地重新获取锁。如果同一个线程永远获取锁，它如何保证公平性？
浏览 0提问于2018-04-30得票数 3
回答已采纳
4回答
假设我有两个线程，t1和t2，以及一个锁对象m. t1处于一个无限循环中，在每一次迭代中，它抓住m上的一个锁，做一些工作，解锁m，然后立即重新开始。在一次迭代中，t2请求m上的锁，但被t1阻塞，不得不等待。现在，当t1解锁m时，是否保证t2将获得m上的下一个锁？或者，在下一次迭代中，t1可以先于它吗？
通常，是否为等待线程设置了队列？如果t1拥有锁，并且所有希望该锁的剩余线程都按以下顺序被阻塞: t2、t3、.，剩余的线程是否会按照被阻塞的顺序继续执行(例如，t2运行，然后t3等)？
(我简要地阅读了java规范，但找不到答案。如果它在里面，请告诉我，我会更仔细地回去阅读。)
谢谢!(第一次如
浏览 4提问于2011-06-11得票数 8
回答已采纳
1回答
我有这样一种情况，我有一个巨大的地图，我维护一些数据。我的应用程序是多线程的。
一个线程可能会尝试从映射中删除条目，而第二个线程可能会尝试复制映射。下面是描述我的问题的示例代码。
public class CollectionsTest {
static Map<String, String> map = new HashMap<>();
public static void main(String [] args) throws InterruptedException {
for(long i=0;i<1000000; i++)
浏览 0提问于2016-10-14得票数 1
2回答
Java队列中线程的执行
、、、
我有这样的练习：
开发多线程应用程序。使用java.util.concurrent机会。
不使用:同步、BlockingQueue、BlockingDeque
所有希望访问资源的实体都必须是线程。利用OOP的机会。
我的任务是：
免费cashDesk。快餐店有几张现金桌。客户站在一个特定的现金柜台排队，但可能去另一个现金柜台，如果减少或消失的队列那里。
这里是我的解决方案
public class Restaurant {
private static Restaurant instance = null;
private static ReentrantLo
浏览 1提问于2015-06-21得票数 0
回答已采纳
在B.Goetz在实践中的Java并发性中，第13.5节说：
在Java5.0中，读锁的行为更像信号量而不是锁，只保持活动读取器的计数，而不是它们的身份。该行为在Java6中被更改，以跟踪哪些线程已被授予读lock6。
6进行此更改的一个原因是，在java5.0中，锁实现不能区分首次请求读锁的线程和重入的锁请求，这将使公平地读写锁死锁。
我的问题是公平有什么问题？为什么不公平的读写锁不受死锁的影响？
你能解释一下他的意思吗？我的意思是，在何种情况下，公平的Java5下的读写锁会导致死锁？如果它表现得像一个Semaphore，那么为什么公平的Semaphore没有导致死锁呢？
浏览 1提问于2016-05-10得票数 3
回答已采纳
4回答
private static void WaitInQueue(Customer c)
{
synchronized(mutex){
//Do some operation here.
}
}
我需要让线程在继续之前等待(一次只有一个线程)，但是，似乎同步没有使用FIFO来确定下一步应该继续进行的进程。(看起来像LIFO)为什么会这样？
如何确保在同步时等待的第一个线程将是第一个启动锁的线程？
浏览 11提问于2013-11-21得票数 1
回答已采纳
我们在Glassfish (3.1.2)应用程序的多服务器集群中使用infinispan5.3.0。应用程序具有处理事件的用户，这些事件存储在infinispan缓存中。
在某些(高峰？)在infinispan日志中，我们看到了很多下面的堆栈跟踪：
2015.04.24_14:41:47,482 - ERROR org.infinispan.interceptors.InvocationContextInterceptor: ISPN000136: Execution error [Thread=http-thread-pool-26861(93)]
org.infinispan.util.c
浏览 4提问于2015-04-24得票数 1
当监视器对象中的线程调用conditionVariable.await()方法时，我看到全局互斥锁已在监视器对象中解锁。但是，当锁被解锁时，哪个队列是优先级的？因为您都有一个互斥队列，所有线程都在监视器外等待，您也有另一个conditionVariable队列。那么，当互斥锁被解锁时，哪个线程可以访问对象，对象外互斥锁队列中的第一个线程还是conditionVariable队列中的第一个线程？哪个队列被排序？
浏览 1提问于2014-02-03得票数 0
回答已采纳
1回答
爪哇公平信号量
、、
我试图理解这个古老的考试任务的答案，在这个任务中，学生应该使用javas reentrantlock实现一个公平的二进制信号量。我不明白这些柜台的意义：
int next = 0;
int nextToGo = 0;
int myNumber;
它在对任务的描述中说，“您可以假设程序中最多有20个使用信号量的线程，而且，在程序的一次运行期间，最多将执行1000万个信号量操作。”在任务的解决方案中，它说：“每个试图获取信号量的线程都必须在队列中注册自己，并且只有在线程离开之前才离开队列。每个线程使用32位计数器记住自己在队列中的位置。计数器不会环绕，因为在信号量上最多执行1000万次操作，但是
浏览 2提问于2016-08-15得票数 3
回答已采纳
1回答
我真的很困惑为什么这个特性需要java。当公平模式可以与ex：ReentrantLock, ReadWriteLock, Semaphore一起使用时，请分享一些实际的例子。
浏览 2提问于2014-10-19得票数 1
回答已采纳
3回答
我试图分别运行两个线程，但它没有分别运行。这是我的代码：
static int shared = 0;
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 1000; ++i){
if (tru
浏览 0提问于2018-05-10得票数 2
回答已采纳
这是ReentrantLock#tryLock的源代码：
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
我的问题是：
ReentrantLock中有两种类型的同步器: FairSync和NonFairSync。为什么只使用NonFairSync？
浏览 1提问于2017-10-08得票数 0
2回答
哪个线程将获得锁？
、、、
假设我们有多处理器机器和多线程应用程序。如果两个线程可以访问一个同步的方法，并且它们同时被执行，那么哪个线程将获得锁？否则会发生什么？
谢谢
浏览 4提问于2010-10-17得票数 5
回答已采纳
1回答
类可重入(True)锁的Lock接口的工作方式是使用BlockingQueue存储希望获取锁的线程。在这种情况下，线程“先来，先出去”-FIFO。一切都很清楚。
但是“不公平的锁”去哪里了，或者ReentrantLock(假的)。它们的内部执行情况如何？操作系统如何决定现在要选择哪个线程？最重要的是，这些线程现在是否也存储在队列中或存储在哪里？(他们一定在某个地方)
浏览 0提问于2020-08-15得票数 5
回答已采纳
2回答
我对Java不允许下面的代码尽可能并发地运行感到非常失望。当没有同步时，两个线程切换得更频繁，但是当尝试访问同步的方法时，第二个线程获得锁的时间会太长(比如30秒)，并且在第一个线程从第二个线程获得锁之前也是如此。什么代码可以更好地共享锁：
public synchronized static void i()
{
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] f)
{
Thread t = new Thre
浏览 2提问于2012-03-04得票数 2
回答已采纳
1回答
在Java中，我们可以通过使用Lock接口和ReentrantLock类实现公平性，如下所示：
Lock lock=new ReentrantLock(true);
一旦我们实现了公平性，那么在多个线程等待访问锁的情况下，等待时间最长的线程被赋予访问锁的权限。
有谁能提供JVM如何让线程等待很长时间的详细信息，即JVM是如何实现公平性的。
浏览 5提问于2016-04-24得票数 3
回答已采纳
1回答
Java中的互斥和信号量
、、、
Mutexes和信号量在Java中是否有很多有用的类，请记住同步实用程序也已经提供了？或者，与C++相比，它们只是为了完整性而提供的？我没有找到太多关于Mutexes和信号量的报道。
浏览 0提问于2015-08-03得票数 0
我有一段使用Java Thread的代码：
public class ThreadExample implements Runnable{
public Thread thread;
static int i = 0;
ThreadExample(){
thread = new Thread(this);
thread.start();
}
public static void main(String[] args) {
ThreadExample example = new ThreadExample
浏览 0提问于2012-12-23得票数 1
回答已采纳
3回答
我在Java语言中使用过synchronized关键字和可重入锁，但我不明白它们有什么不同，也不知道哪一个适合于给定的情况。
我如何决定什么时候应该使用synchronized，什么时候应该使用可重入锁？
浏览 3提问于2012-01-31得票数 23
1回答
我研究ReentrantReadWriteLock
来自java文档的代码片段：
在当前最老的等待写入线程获得并释放写锁之前，线程将不会获取读锁。
正如我所理解的那样。
读取时间-1时间单位
写入持续时间-3时间单元
时间0-获得写入锁
时间1-读锁试读
时间2-写锁尝试写
因此，我期望以下顺序：
第一写
第二写
朗读
我的实验代码：
public class RWLockCalculator {
static long initTime = System.currentTimeMillis();
private static i
浏览 0提问于2014-04-16得票数 3
回答已采纳
2回答
它是Java中的一个简单的信号量。虽然它以惊人的成绩通过了所有的测试，但我仍然不确定它是否正确。
例如，在名为mLock.lockInterruptibly();的方法中，我最不确定的是mLock.lock();与aquire()之间的关系。最后我使用了lockInterruptibly()，因为如果中断了调用lockInterruptibly()的线程，那么就会抛出InterruptedException。
package edu.vuum.mocca;
import java.util.concurrent.locks.ReentrantLock;
import java.util.co
浏览 0提问于2014-06-17得票数 7
回答已采纳
1回答
我正在开发可以从不同线程进入的同步函数。我需要做的机制，允许进入我的函数根据FIFO方法的情况下，当几个线程正在调用它。在Java1.4中解决此任务的方法是什么？
浏览 13提问于2016-07-22得票数 0
我有十个通用函数，它们都在我的框架中频繁运行。其中两个函数为A类型，其余8个函数为B类型。我希望能够同时运行类型A函数，但不允许在A类型函数运行时运行B类型函数。同样，如果B类型函数正在运行，我不希望任何类型的A函数被允许运行。我也不希望任何其他类型的B运行，如果一个已经在运行。
除了使用ReentrantReadWriteLock之外，还有什么更好的方法来实现这个(特别是在Java中)，即A类型周围的读锁和B类型的写锁？
ReentrantReadWriteLock用于大多数时间需要读取器锁，而编写器锁是“偶尔”需要的。但是，在我的例子中，所有的函数都一直在使用，这意味着所有函数都以相同的频
浏览 2提问于2017-10-24得票数 0
回答已采纳
我用ReentrantReadWriteLock编写了以下测试代码，以理解公平模式和非公平模式之间的区别。但是，在这两种模式中，结果和输出总是一样的。它似乎总是在公平的模式下工作。谁能解释一下在哪种情况下，公平和不公平模式会导致不同的行为？
package lockTest;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyLockTest {
static private ReadWri
浏览 0提问于2019-04-19得票数 1
回答已采纳
关于Java语言中的ReadWriteLocks (特别是ReentrantReadWriteLock实现)，我只想提一个简短的问题，因为我觉得sun文档并不清楚。
如果一个线程持有一个读锁，而另一个线程请求一个写锁，会发生什么？写锁线程是否必须等待当前持有的所有读锁被释放？另外，是否所有新的读锁请求都会被阻塞，直到写锁被授予并释放？
谢谢
浏览 7提问于2009-07-07得票数 0
回答已采纳
3回答
我一直在学习Java多线程概念。我经历得越多，我就越迷茫。
现在，我还不了解Java中类级别、对象级别、显式锁定和内在锁定之间的区别。谁能告诉我哪一种是什么？此外，如果我能得到一些例子来理解，这将对我很有帮助。
浏览 3提问于2014-10-31得票数 5
回答已采纳
我想要创建公平的锁，这样每个线程都会被一个接一个地锁，而不管优先级如何。
import java.util.concurrent.locks.ReentrantLock;
public class StarvationRunnable implements Runnable {
private ReentrantLock lock = new ReentrantLock(true);
public void doLongTask() {
lock.lock();
// to imitate long running task in crit
浏览 2提问于2014-05-19得票数 2
回答已采纳
1回答
有人熟悉票证锁定算法，它取代了linux内核中的基本自旋锁算法吗？我希望能找到这方面的专家。我从一些在线消息来源中了解到，票证锁定算法应该更快，因为朴素算法在CPU总线上淹没了所有试图同时获得锁的线程。有人能为我确认/否认吗？
我自己做了一些实验。票证锁定确实是公平的，但它的性能与线程自旋锁算法相当。事实上，它只是稍微慢了一点。
在我看来，一个不公平的算法应该更快一点，因为在早期占据锁的线程完成得更快，使调度程序的工作量更少。
我想对此有更多的看法。如果它不是更快，为什么在内核中实现票证锁，为什么没有在用户空间中使用它？谢谢!
浏览 1提问于2012-05-01得票数 3
我试图编写一个代码来显示ReentrantLock的不公平(当ctor被传递给fair=false时)。令我惊讶的是，ReentrantLock是完全公平的。
我的测试有以下逻辑:生成20个线程，其"id“从0到19。所有线程共享一个ReentrantLock。然后，按时间顺序排列：
线程0锁定锁。
线程1到19块在lock()上，顺序是1，然后是2，然后是3，.，然后是19
线程0解锁锁。这是对公平性的第一次测试，如果锁是公平的，线程1应该在此后得到它。
当线程1有锁时，他也会释放它。第二个公平性测试:线程2现在应该得到它。
等
我原以为，有时候，一个线程
浏览 1提问于2017-02-24得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
