java并发容器类

一、概述

     在Java中,普通常用集合

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

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

 

二、并发容器

 

一、结构图

 

二、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