为什么在演示中同步工作时 ReentrantLock 不工作?
Why ReentrantLock is not working while synchronized work in the demo?
我正在尝试遵循 ReentrantLock Example in Java, Difference between synchronized vs ReentrantLock 类教程。我在 as
上有一个以-ea
开头的演示
public class ReentrantLockZero {
private static ReentrantLock CountLock = new ReentrantLock();
private static int count = 0;
private static final int RESULT_COUNT = 10_000;
public static void main(String... args) throws Exception {
ThreadPoolExecutor threadPoolExecutor = getMyCachedThreadPool();
for (int i = 0; i < RESULT_COUNT; ++i) {
threadPoolExecutor.submit(ReentrantLockZero::getCount);
threadPoolExecutor.submit(ReentrantLockZero::getCountUsingLock);
}
threadPoolExecutor.shutdown();
threadPoolExecutor.awaitTermination(10, TimeUnit.SECONDS);
assert count == RESULT_COUNT * 2;
}
private static synchronized int getCount() {
count++;
System.out.println(Thread.currentThread().getName() + " counting in synchronized: " + count);
return count;
}
private static int getCountUsingLock() {
CountLock.lock();
try {
count++;
System.out.println(Thread.currentThread().getName() + " counting in lock: " + count);
return count;
} finally {
CountLock.unlock();
}
}
}
当使用ReentrantLock
作为第二种方法getCountUsingLock
时,我会得到java.lang.AssertionError
,但是当我将它们注释掉以使用synchronized
时,就可以了。
考虑到它的ReentrantLock,我删除了class中定义的CountLock
并使用本地锁如下,但它仍然不起作用。
private static int getCountUsingLock() {
ReentrantLock countLock = new ReentrantLock();
countLock.lock();
try {
count++;
System.out.println(Thread.currentThread().getName() + " counting in lock: " + count);
return count;
} finally {
countLock.unlock();
}
}
这里遗漏了什么?
任何帮助将不胜感激;)
有点像我自己的傻瓜。
之所以如此,是因为我实际上锁定了不同的对象。
private static synchronized int getCount()
等于
private static synchronized (ReentrantLockZero.class) int getCount()
而 new ReentrantLock();
始终是一个新对象,无法使用不同的锁来消除 race condition。
真傻,下面的演示很容易解决这个问题
public class ReentrantLockZero {
private static ReentrantLock CountLock = new ReentrantLock();
private static int synchronisedCount = 0;
private static int lockedCount = 0;
private static final int RESULT_COUNT = 10_000;
public static void main(String... args) throws Exception {
ThreadPoolExecutor threadPoolExecutor = getMyCachedThreadPool();
for (int i = 0; i < RESULT_COUNT; ++i) {
threadPoolExecutor.submit(ReentrantLockZero::getSynchronisedCount);
threadPoolExecutor.submit(ReentrantLockZero::getCountUsingLock);
}
threadPoolExecutor.shutdown();
threadPoolExecutor.awaitTermination(10, TimeUnit.SECONDS);
assert synchronisedCount == RESULT_COUNT;
assert lockedCount == RESULT_COUNT;
}
private static synchronized int getSynchronisedCount() {
synchronisedCount++;
System.out.println(Thread.currentThread().getName() + " counting in synchronized: " + synchronisedCount);
return synchronisedCount;
}
private static int getCountUsingLock() {
CountLock.lock();
try {
lockedCount++;
System.out.println(Thread.currentThread().getName() + " counting in lock: " + lockedCount);
return lockedCount;
} finally {
CountLock.unlock();
}
}
}
为什么 synchronized
有效?因为这两种方法只锁定一个锁,所以直接解决了竞争条件。
有点容易被教程骗了;我真丢人;(