Java并发数据结构（7.2）

Map（映射）

• Hashtable 同步安全，写多读少
• HashMap 不安全
• Collections.synchronizedMap(Map map) 基于synchronized，效率差
• ConcurrentHashMap 读多写少，非阻塞

package map;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class MapTest{    
 
    public static void main(String[] args) throws InterruptedException{

        //线程不安全
        Map<Integer,String> unsafeMap = new HashMap<Integer,String>();
        //线程安全
        Map<Integer,String> safeMap1 = Collections.synchronizedMap(new HashMap<Integer,String>());
        //线程安全
        ConcurrentHashMap<Integer,String> safeMap2 = new ConcurrentHashMap<Integer,String>();

        MapThread t1 = new MapThread(unsafeMap);
        MapThread t2 = new MapThread(safeMap1);
        MapThread t3 = new MapThread(safeMap2);

        //unsafeMap的运行测试
        for(int i = 0; i < 10; i++){
        	Thread t = new Thread(t1);
        	t.start();
        }       
        for(int i = 0; i < 10; i++) {
        	Thread t = new Thread(t2);
            t.start();
        }
        for(int i = 0; i < 10; i++) {
        	Thread t = new Thread(t3);
            t.start();
        }

        //等待子线程执行完
        Thread.sleep(2000);
 
        System.out.println("mapThread1.map.size() = " + t1.map.size());
        System.out.println("mapThread2.map.size() = " + t2.map.size());
        System.out.println("mapThread3.map.size() = " + t3.map.size());

        //输出set中的值
        System.out.println("unsafeMap：");
        Iterator iter = t1.map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry<Integer,String> entry = (Map.Entry<Integer,String>)iter.next();
            // 获取key
            System.out.print(entry.getKey() + ":");
            // 获取value
            System.out.print(entry.getValue() + " ");
        }
        System.out.println();
        
        System.out.println("safeMap1：");
        iter = t2.map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry<Integer,String> entry = (Map.Entry<Integer,String>)iter.next();
            // 获取key
            System.out.print(entry.getKey() + ":");
            // 获取value
            System.out.print(entry.getValue() + " ");
        }

        System.out.println();
        System.out.println("safeMap2：");
        iter = t3.map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry<Integer,String> entry = (Map.Entry<Integer,String>)iter.next();
            // 获取key
            System.out.print(entry.getKey() + ":");
            // 获取value
            System.out.print(entry.getValue() + " ");
        }
        System.out.println();
        System.out.println("mapThread1.map.size() = " + t1.map.size());
        System.out.println("mapThread2.map.size() = " + t2.map.size());
        System.out.println("mapThread3.map.size() = " + t3.map.size());
    }
}

class MapThread implements Runnable
{
	public Map<Integer,String> map;

    public MapThread(Map<Integer,String> map){
        this.map = map;
    }

    @Override
    public void run() {
        int i=0;
        
        while(i<100)
        {
        	//把当前线程名称加入map中
            map.put(i++,Thread.currentThread().getName());
            try {
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }        
    }
}

Queue&Deque

(队列&双向队列)

• ConcurrentLinkedQueue 非阻塞
• ArrayBlockingQueue/LinkedBlockingQueue 阻塞

`package queue;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentLinkedDeque;

public class QueueTest {

public static void main(String[] args) throws InterruptedException{

    //线程不安全
    Deque<String> unsafeQueue = new ArrayDeque<String>();
    //线程安全
    ConcurrentLinkedDeque<String> safeQueue1 = new ConcurrentLinkedDeque<String>();

    ArrayBlockingQueue<String> safeQueue2 = new ArrayBlockingQueue<String>(100);

    QueueThread t1 = new QueueThread(unsafeQueue);
    QueueThread t2 = new QueueThread(safeQueue1);
    QueueThread t3 = new QueueThread(safeQueue2);

    for(int i = 0; i < 10; i++){
        Thread thread1 = new Thread(t1, String.valueOf(i));
        thread1.start();
    }
    for(int i = 0; i < 10; i++) {
        Thread thread2 = new Thread(t2, String.valueOf(i));
        thread2.start();
    }
    for(int i = 0; i < 10; i++) {
        Thread thread3 = new Thread(t3, String.valueOf(i));
        thread3.start();
    }

    //等待子线程执行完
    Thread.sleep(2000);

    System.out.println("queueThread1.queue.size() = " + t1.queue.size());
    System.out.println("queueThread2.queue.size() = " + t2.queue.size());
    System.out.println("queueThread3.queue.size() = " + t3.queue.size());

    //输出queue中的值
    System.out.println("unsafeQueue：");
    for(String s:t1.queue)
    {
    	System.out.print(s + " ");
    }
    System.out.println();
    System.out.println("safeQueue1：");
    for(String s:t2.queue)
    {
    	System.out.print(s + " ");
    }
    System.out.println();
    System.out.println("safeQueue2：");
    for(String s:t3.queue)
    {
    	System.out.print(s + " ");
    }
}

}

class QueueThread implements Runnable{
public Queue queue;

public QueueThread(Queue<String> queue){
    this.queue = queue;
}

@Override
public void run() {
	int i = 0;
	while(i<10)
	{
		i++;
		try {
            Thread.sleep(10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //把当前线程名称加入list中
        queue.add(Thread.currentThread().getName());
	}        
}

}`
定位到出现异常位置，

出现异常的原因：因为t1线程不安全，当出现数据不一致时就会报出异常。

总结： 采用并发的数据结构可以避免同时读写引发的数据不一致问题，提高数据结构使用效率。