java并发容器类-蒲公英云

java并发容器类

冷不防 2021-10-14 05:16 720阅读 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);
    }