【发布时间】：2015-03-23 18:12:30
【问题描述】：
场景：一个类使用 Jdk1.7 java.util.HashMap，get() 和 put() 是唯一调用的方法。我试图避免 get() 方法上的同步。之前同步的方法 ClassloaderHashMap.get() 可以在必须加载新类时阻塞我所有的线程几秒钟。类加载的本质是对象被添加到 HashMap 并且永远不会被删除。我的应用程序使用 400 个线程和 30'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();
}
}
}
示例输出 - 可能出现空条目但不会导致错误，在这种情况下调用同步方法：
*** 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]
【问题讨论】：
-
HashMap提供从一开始就不保证线程安全；那么你的测试有什么意义呢？
标签： java performance collections thread-safety