场景：一个类使用Jdk1.7 java.util.HashMap，get（）和put（）是唯一被调用的方法。我试图避免get（）方法同步。以前同步的方法ClassloaderHashMap.get（）可以在必须加载新类时阻止所有线程的秒数。类加载的本质是将对象添加到HashMap中并且永远不会删除。我的应用程序使用400个线程和30＆000; 000类。我不能使用ConcurrentHashMap。
/**
* Class to simulate lock free reads from HashMap in WebClassLoader.
*/
public static class ClassloaderHashMap {
private final HashMap<String, String> testHashMap = new HashMap<String, String>();
public String get(String key) {
if (testHashMap.containsKey(key)) {
String result = testHashMap.get(key);
if (result != null) {
return result;
}
}
// call synchronized method
return writeAndGet(key);
}
private synchronized String writeAndGet(String key) {
// find and load class by key, for the test scenario simply use value=key
testHashMap.put(key, key);
return testHashMap.get(key);
}
}
问题：此解决方案是否存在潜在危险？
我使用以下代码成功测试了多线程场景：
package alex;
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
public class PerfTestLockFreeReadHashMap {
private static final ExecutorService EXECUTOR = Executors.newCachedThreadPool();
private static final int KEY_COUNT = 30179; // same number of loaded classes
// as in my app
private static int NUM_WRITERS = 20;
private static int NUM_READERS = 400;
private static long TEST_DURATION_MS = 1000;
private static final String[] keysArray = new String[KEY_COUNT];
static {
for (int i = 0; i < keysArray.length; i++) {
keysArray[i] = "com.company.SomeClass-" + i;
}
}
/**
* Class to simulate lock free reads from HashMap in WebClassLoader.
*/
public static class ClassloaderHashMap {
private final HashMap<String, String> testHashMap = new HashMap<String, String>();
private AtomicLong reads = new AtomicLong();
private AtomicLong nullentries = new AtomicLong();
private AtomicLong writes = new AtomicLong();
public String get(String key) {
if (testHashMap.containsKey(key)) {
reads.incrementAndGet();
String result = testHashMap.get(key);
if (result != null) {
return result;
} else {
nullentries.incrementAndGet();
}
}
// call synchronized method
return writeAndGet(key);
}
public synchronized String writeAndGet(String key) {
writes.incrementAndGet();
testHashMap.put(key, key);
return testHashMap.get(key);
}
@Override
public String toString() {
return "ClassloaderHashMap [Lock-free reads=" + reads + ", Null entries=" + nullentries + ", writes=" + writes + "]";
}
}
public static void main(final String[] args) throws Exception {
for (int i = 0; i < 10; i++) {
ClassloaderHashMap classloaderHashMap = new ClassloaderHashMap();
System.out.println("*** Run - " + i);
perfRun(classloaderHashMap);
System.out.println(classloaderHashMap);
}
EXECUTOR.shutdown();
}
public static void perfRun(final ClassloaderHashMap classloaderHashMap) throws Exception {
final CyclicBarrier startBarrier = new CyclicBarrier(NUM_READERS + NUM_WRITERS + 1);
final CountDownLatch finishLatch = new CountDownLatch(NUM_READERS + NUM_WRITERS);
final AtomicBoolean runningFlag = new AtomicBoolean(true);
for (int i = 0; i < NUM_WRITERS; i++) {
EXECUTOR.execute(new WriterRunner(classloaderHashMap, i, runningFlag, startBarrier, finishLatch));
}
for (int i = 0; i < NUM_READERS; i++) {
EXECUTOR.execute(new ReaderRunner(classloaderHashMap, i, runningFlag, startBarrier, finishLatch));
}
awaitBarrier(startBarrier);
Thread.sleep(TEST_DURATION_MS);
runningFlag.set(false);
finishLatch.await();
System.out.format("%d readers %d writers \n", NUM_READERS, NUM_WRITERS);
}
public static void awaitBarrier(final CyclicBarrier barrier) {
try {
barrier.await();
} catch (final Exception ex) {
throw new RuntimeException(ex);
}
}
public static class WriterRunner implements Runnable {
private final int id;
private final AtomicBoolean runningFlag;
private final CyclicBarrier barrier;
private final CountDownLatch latch;
private final ClassloaderHashMap classloaderHashMap;
public WriterRunner(final ClassloaderHashMap classloaderHashMap, final int id, final AtomicBoolean runningFlag, final CyclicBarrier barrier,
final CountDownLatch latch) {
this.id = id;
this.runningFlag = runningFlag;
this.barrier = barrier;
this.latch = latch;
this.classloaderHashMap = classloaderHashMap;
}
@Override
public void run() {
awaitBarrier(barrier);
int writeCounter = 0;
while (runningFlag.get()) {
String key = writeCounter + keysArray[writeCounter % KEY_COUNT] + id;
String result = classloaderHashMap.get(key);
if (result == null) {
result = classloaderHashMap.writeAndGet(key);
}
if (!key.equals(result)) {
throw new RuntimeException(String.format("Got %s instead of %s.\n", result, key));
}
++writeCounter;
}
latch.countDown();
}
}
public static class ReaderRunner implements Runnable {
private final int id;
private final AtomicBoolean runningFlag;
private final CyclicBarrier barrier;
private final CountDownLatch latch;
private final ClassloaderHashMap classloaderHashMap;
public ReaderRunner(final ClassloaderHashMap classloaderHashMap, final int id, final AtomicBoolean runningFlag, final CyclicBarrier barrier,
final CountDownLatch latch) {
this.id = id;
this.runningFlag = runningFlag;
this.barrier = barrier;
this.latch = latch;
this.classloaderHashMap = classloaderHashMap;
}
@Override
public void run() {
awaitBarrier(barrier);
int readCounter = 0;
while (runningFlag.get()) {
String key = keysArray[readCounter % keysArray.length] + "-" + id;
String result = classloaderHashMap.get(key);
if (result == null) {
result = classloaderHashMap.writeAndGet(key);
}
if (!key.equals(result)) {
throw new RuntimeException(String.format("Got %s instead of %s.\n", result, key));
}
++readCounter;
}
latch.countDown();
}
}
}
示例输出 - 可以发生null条目但不会导致错误，在这种情况下调用synchronized方法：
*** Run - 0
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=4288664, Null entries=0, writes=589699]
*** Run - 1
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=4177513, Null entries=0, writes=965519]
*** Run - 2
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=4701346, Null entries=0, writes=971986]
*** Run - 3
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=8181871, Null entries=1, writes=2076311]
*** Run - 4
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=3225071, Null entries=0, writes=616041]
*** Run - 5
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=2923419, Null entries=0, writes=1762663]
*** Run - 6
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=5514584, Null entries=0, writes=1090732]
*** Run - 7
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=4037333, Null entries=0, writes=948106]
*** Run - 8
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=6604630, Null entries=0, writes=750456]
*** Run - 9
400 readers 20 writers
ClassloaderHashMap [Lock-free reads=5263678, Null entries=0, writes=894637]
答案 0 :(得分：2)
不，HashMap不是线程安全的。如果有一个线程写入映射，另一个线程从中读取，则读取线程可能会看到映射处于不一致状态。当然，这可能会在很长一段时间内正确地进行，但是会产生一个难以重现和发现的错误。
使用同步get()方法，问题是对地图的所有访问都会变得同步。因此，当两个线程同时尝试从地图读取时，必须等待另一个（尽管同时读取不是问题）。有400个线程，这确实可能导致合理的延迟。
问题的解决方案是使用java.util.concurrent.locks.ReadWriteLock。 （Java为此接口提供了java.util.concurrent.locks.ReentrantReadWriteLock实现。）使用此锁定，您可以确保任意数量的线程可以同时具有对对象的读取权限，但只有一个线程可以写入映射（如果是一个线程）写作，然后没有其他线程可能正在阅读）。查看Java API文档以了解如何使用诸如lock。
答案 1 :(得分：0)
是的，此解决方案存在潜在危险。它通过不保证“先发生”主体来创建内存不一致。
即使put()方法已同步，您的get()方法也可以返回null或old and incorrect value或覆盖刚通过{{ 1}}（也不知道为什么要从put()拨打put()。让get()返回get()）。
如果你不关心数据的准确性，那么你可以实现这个，但绝对不推荐解决方案。
答案 2 :(得分：0)
是的。
由于您在没有同步的情况下阅读，因此可以看到损坏的状态。实际上你正在努力建立＆＃34; Double Checked Locking＆＃34;哪个不起作用，请参阅http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html