java并发容器类

冷不防 2021-10-14 05:16 576阅读 0赞

## 一、概述 ##

在Java中,普通常用集合

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTUxMzQ2_size_16_color_FFFFFF_t_70][]1.这些集合在我们编程中经常用到，但是在这些集合中除HashTale外，其他的都是属于线程不安全的，意味着我们在多线程情况下使用这些集合，我们的数据不能得到保障。单是HashTable的底层实现是给整个数组加了一把锁，意味着在多线程下，势必会出现线程竞争资源的情况，轻量级锁不停自旋后会升级为重量级锁，性能较差。

2.为了能够在多线程情况下操作数据，java在J.U.C包下提供了一些并发容器类供我们操作，

## 二、并发容器 ##

### 一、结构图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTUxMzQ2_size_16_color_FFFFFF_t_70 1][]

### 二、ConcurrentHashMap ###

1.在jdk1.8之前，HashTable采用的结构是给整个数组上锁，而ConcurrentHashMap采用的则是分段锁，将一个数组分成很多个segment，在jdk１.8之后，放弃了分段锁的这种方式，而是使用底层数据结构和hashMap一样的数组＋链表＋红黑树。

２．在一个桶中，如果node节点的个数大于８之后，就会将原本链表的结构转换成红黑树，红黑树查找数据的时间复杂度为树的深度，即Ｏ(logn),在node节点的个数小于６之后，又会将红黑树的结构转化成链表，同时使用了unsafe类，即一些CAS操作。

３.基本使用

package com.test;
    
    import java.util.concurrent.ConcurrentHashMap;
    /**
     *线程类，往map里面存放数据，存放一个数据休眠时间20毫秒 
     */
    public class PuThread implements Runnable{
    
    	private ConcurrentHashMap<String,String> map;
    	
    	public PuThread(ConcurrentHashMap<String,String> map){
    		this.map=map;
    	}
    	
    	public void run() {
    		for(int i=0;i<10;i++){
    			try {
    				Thread.sleep(20);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			map.put(String.valueOf(i), String.valueOf(i));
    		}
    	}
    
    }

###  一个线程用来存放数据，为了模拟在多线程下操作数据，我们同时创建了另外一个线程来存放数据 ###

package com.test;
    
    import java.util.concurrent.ConcurrentHashMap;
    /**
     *线程类，往map里面存放数据，存放一个数据休眠时间20毫秒 
     */
    public class PuThread2 implements Runnable{
    
    	private ConcurrentHashMap<String,String> map;
    	
    	public PuThread2(ConcurrentHashMap<String,String> map){
    		this.map=map;
    	}
    	
    	public void run() {
    		for(int i=10;i<20;i++){
    			try {
    				Thread.sleep(20);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			map.put(String.valueOf(i), String.valueOf(i));
    		}
    	}
    
    }

### 最后又创建了一个线程用来读取里面的数据 ###

package com.test;
    
    import java.util.concurrent.ConcurrentHashMap;
    
    public class GeThread implements Runnable{
    
    	private ConcurrentHashMap<String,String> map;
    	
    	public GeThread(ConcurrentHashMap<String,String> map){
    		this.map=map;
    	}
    	
    	public void run() {
    		for(int i=0;i<20;i++){
    			try {
    				Thread.sleep(20);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println(map.get(String.valueOf(i)));
    		}
    	}
    
    }

## ##

来看下主方法

public class Test1 {
    
    	public static void main(String[] args) {
    		System.out.println("开始");
    		currentHash();
    	}
    	public static void currentHash(){
    		ConcurrentHashMap<String, String> map=new ConcurrentHashMap<String, String>();
    		System.out.println("开始");
    		map.put("aa", "aa");
    		map.put("bb", "bb");
    		map.put("cc", "cc");
    		map.put("dd", "dd");
    		map.put("ee", "ee");
    		Thread pu=new Thread(new PuThread(map));
    		Thread pu2=new Thread(new PuThread2(map));
    		Thread ge=new Thread(new GeThread(map));
    		pu.start();
    		pu2.start();
    		ge.start();
    		System.out.println(map.toString());
    	}
    	
    }

### 三、**CopyOnWriteArrayList** ###

１.实现了list接口，底层使用的是可重入锁，ReentrantLock

/** The lock protecting all mutators */
        final transient ReentrantLock lock = new ReentrantLock();

２.加锁位置，在设置元素时加了锁。

**
         * Replaces the element at the specified position in this list with the
         * specified element.
         *
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        public E set(int index, E element) {
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                Object[] elements = getArray();
                E oldValue = get(elements, index);
    
                if (oldValue != element) {
                    int len = elements.length;
                    Object[] newElements = Arrays.copyOf(elements, len);
                    newElements[index] = element;
                    setArray(newElements);
                } else {
                    // Not quite a no-op; ensures volatile write semantics
                    setArray(elements);
                }
                return oldValue;
            } finally {
                lock.unlock();
            }
        }

３．同时我们可以发现在get方法（即读的时候）并没有加锁

/**
         * {@inheritDoc}
         *
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        public E get(int index) {
            return get(getArray(), index);
        }

４．所以CopyOnWriteArrayList支持读多写少的情况

### 四、ArrayBlockingQueue ###

1.数组实现的有界队列

### 五、LinkedBlockingQueue ###

1.LinkedBlockingQueue如果不手动指定容量，那么的他的容量将为Integer.MAX\_VALUE

### 六、SynchronousQueue ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTUxMzQ2_size_16_color_FFFFFF_t_70]: /images/20211013/523ced6fc1f948959e0c10fc9dfe42d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTUxMzQ2_size_16_color_FFFFFF_t_70 1]: /images/20211013/2f2f29d8740040b8ba2de5abfdc59824.png