AtomicLongMap的使用

AtomicLongMap是Google Guava项目的一个类，它是线程安全、支持并发访问的。

 

Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等

 

public class GuavaTest {
    //来自于Google的Guava项目
    AtomicLongMap<String> map = AtomicLongMap.create(); //线程安全，支持并发
    
    Map<String, Integer> map2 = new HashMap<String, Integer>(); //线程不安全
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); //为map2增加并发锁
    
    ConcurrentHashMap<String, Integer> map3 = new ConcurrentHashMap<String, Integer>(); //线程安全，但也要注意使用方式
    
    private int taskCount = 100;
    CountDownLatch latch = new CountDownLatch(taskCount); //新建倒计时计数器，设置state为taskCount变量值
    
	public static void main(String[] args) {
	    GuavaTest t = new GuavaTest();
        t.test();
	}
	
	private void test(){
	    //启动线程
	    for(int i=1; i<=taskCount; i++){
	        Thread t = new Thread(new MyTask("key", 100));
	        t.start();
	    }
	    
	    try {
	        //等待直到state值为0，再继续往下执行
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
	    
	    System.out.println("##### AtomicLongMap #####");
	    for(String key : map.asMap().keySet()){
	        System.out.println(key + ": " + map.get(key));
	    }
	    
        System.out.println("##### HashMap #####");
        for(String key : map2.keySet()){
            System.out.println(key + ": " + map2.get(key));
        }
        
        System.out.println("##### ConcurrentHashMap #####");
        for(String key : map3.keySet()){
            System.out.println(key + ": " + map3.get(key));
        }
	}
	
	class MyTask implements Runnable{
	    private String key;
        private int count = 0;
        
        public MyTask(String key, int count){
            this.key = key;
            this.count = count;
        }
        
        @Override
        public void run() {
            try {
                for(int i=0; i<count; i++){
                    map.incrementAndGet(key); //key值自增1后，返回该key的值
                    
                    //对map2添加写锁，可以解决线程并发问题
                    lock.writeLock().lock();
                    try{
                        if(map2.containsKey(key)){
                            map2.put(key, map2.get(key)+1);
                        }else{
                            map2.put(key, 1);
                        }
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }finally{
                        lock.writeLock().unlock();
                    }
                    
                    //虽然ConcurrentHashMap是线程安全的，但是以下语句块不是整体同步，导致ConcurrentHashMap的使用存在并发问题
                    if(map3.containsKey(key)){
                        map3.put(key, map3.get(key)+1);
                    }else{
                        map3.put(key, 1);
                    }
                    
                    //TimeUnit.MILLISECONDS.sleep(50); //线程休眠50毫秒
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                latch.countDown(); //state值减1
            }
        }
    }
	
}

 

执行结果如下：

##### AtomicLongMap #####

key: 10000

##### HashMap #####

key: 10000

##### ConcurrentHashMap #####

key: 9311