并发容器

最新推荐文章于 2024-10-01 09:29:45 发布

naki_bb

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量135

点赞数

分类专栏：并发编程文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_33753147/article/details/106333779

版权

并发编程专栏收录该内容

9 篇文章 0 订阅

订阅专栏

ConcurrentHashMap

Hashmap多线程会导致HashMap的Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空，就会产生死循环获取Entry。

HashTable使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞或轮询状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

putIfAbsent() ：没有这个值则放入map，有这个值则返回key本来对应的值。

预备知识

Hash

散列，哈希：把任意长度的输入通过一种算法（散列），变换成为固定长度的输出，这个输出值就是散列值。属于压缩映射，容易产生哈希冲突。Hash算法有直接取余法等。

产生哈希冲突时解决办法：开放寻址；2、再散列；3、链地址法（相同hash值的元素用链表串起来）。

ConcurrentHashMap在发生hash冲突时采用了链地址法。

md4,md5,sha-hash算法也属于hash算法，又称摘要算法

位运算

高位地位

31	30	29																								5	4	3	2	1	0
0	0	0																								1	0	1	0	0	0

由上面的表格可以看出，数字类型在数字渐渐变大时，是由低位慢慢向高位扩展的。

Java实际保存int型时正数第31位 =0 负数：第31位=1

常用位运算有：

位与 & (1&1=1 1&0=0 0&0=0)
位或 | (1|1=1 1|0=1 0|0=0)
位非 ~ （ ~1=0 ~0=1）
位异或 ^ (1^1=0 1^0=1 0^0=0)
<<有符号左移 >>有符号的右移 >>>无符号右移例如：8 << 2 = 32 8>>2 = 2
取模的操作 a % (Math.pow(2,n)) 等价于 a&( Math.pow(2,n)-1)；位运算速率快的多

位运算适用：权限控制，物品的属性非常多时的保存

权限控制示例:（一个字段就可记录多种属性，也适用于电商时一个物品具有多种属性）

public class Permission {
    // 是否允许查询，二进制第1位，0表示否，1表示是
    public static final int ALLOW_SELECT = 1 << 0; // 0001  = 1

    // 是否允许新增，二进制第2位，0表示否，1表示是
    public static final int ALLOW_INSERT = 1 << 1; // 0010  = 2

    // 是否允许修改，二进制第3位，0表示否，1表示是
    public static final int ALLOW_UPDATE = 1 << 2; // 0100  =4

    // 是否允许删除，二进制第4位，0表示否，1表示是
    public static final int ALLOW_DELETE = 1 << 3; // 1000  = 8


    //存储目前的权限状态
    private int flag;

    //增加用户的权限（1个或者多个）
    public void enable(int per) {
        flag = flag | per;
    }

    //禁止用户的权限（1个或者多个）
    public void disable(int per) {
        flag = flag & ~per;
    }

    //判断用户的权限是否存在
    public boolean isAllow(int per) {
        return ((flag & per) == per);
    }

    //判断用户没有的权限
    public boolean isNotAllow(int per) {
        return ((flag & per) == 0);
    }

    public int getFlag() {
        return flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {
        Permission permission = new Permission();
        permission.setFlag(1 + 2 + 4 + 8);//设置用户有所有权限
        permission.disable(ALLOW_INSERT | ALLOW_UPDATE);
        System.out.println("select = " + permission.isAllow(ALLOW_SELECT));
        System.out.println("insert = " + permission.isAllow(ALLOW_INSERT));
        System.out.println("update = " + permission.isAllow(ALLOW_UPDATE));
        System.out.println("delete = " + permission.isAllow(ALLOW_DELETE));
    }
}

运行结果：

select = true
update = false
insert = false
delete = true

JDK1.7中的实现原理

ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment实际继承自可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，每个Segment里包含一个HashEntry数组，我们称之为table，每个HashEntry是一个链表结构的元素。

面试常问：

ConcurrentHashMap实现原理是怎么样的或者问ConcurrentHashMap如何在保证高并发下线程安全的同时实现了性能提升？

答：ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，只要多个修改操作发生在不同的段上，它们就可以并发进行。

初始化:

initialCapacity：初始容量大小，默认16。

loadFactor, 扩容因子，默认0.75，当一个Segment存储的元素数量大于initialCapacity* loadFactor时，该Segment中的table会进行一次扩容。

concurrencyLevel 并发度，默认16。并发度可以理解为程序运行时能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数，实际上就是ConcurrentHashMap中的分段锁个数，即Segment[]的数组长度。如果并发度设置的过小，会带来严重的锁竞争问题；如果并发度设置的过大，原本位于同一个Segment内的访问会扩散到不同的Segment中，CPU cache命中率会下降，从而引起程序性能下降。

保证Segment数组的大小，一定为2的幂，例如用户设置并发度为17，则实际Segment数组大小则为32
保证每个Segment中tabel数组的大小，一定为2的幂，初始化的三个参数取默认值时，table数组大小为2
初始化Segment数组，并实际只填充Segment数组的第0个元素。

定位segment/table

对于某个元素而言，一定是放在某个segment元素的某个table元素中的，所以在定位上，

定位segment：取得key的hashcode值进行一次再散列（通过Wang/Jenkins算法），拿到再散列值后，以再散列值的高位进行取模得到当前元素在哪个segment上。

定位table：同样是取得key的再散列值以后，用再散列值的全部和table的长度进行取模，得到当前元素在table的哪个元素上。

扩容方式

Segment 不扩容，扩容下面的table数组，每次都是将数组翻倍

带来的好处

假设原来table长度为4，那么元素在table中的分布是这样的：

Hash值	15	23	34	56	77
在table中下标	3 = 15%4	3 = 23 % 4	2 = 34%4	0 = 56%4	1 = 77 % 4

扩容后table长度变为8，那么元素在table中的分布变成：

Hash值	56		34			77		15,23
下标	0	1	2	3	4	5	6	7

可以看见 hash值为34和56的下标保持不变，而15,23,77的下标都是在原来下标的基础上+4即可，可以快速定位和减少重排次数。

Size方法

size的时候进行两次不加锁的统计，两次一致直接返回结果，不一致，重新加锁再次统计，所以尽量少使用size方法，可能会全部segment段加锁

弱一致性

get方法和containsKey方法都是通过对链表遍历判断是否存在key相同的节点以及获得该节点的value。但由于遍历过程中其他线程可能对链表结构做了调整，因此get和containsKey返回的可能是过时的数据，这一点是ConcurrentHashMap在弱一致性上的体现。

JDK1.8实现原理

与1.7相比的重大变化

取消了segment数组，直接用table保存数据，锁的粒度更小，减少并发冲突的概率。
存储数据时采用了链表+红黑树的形式，纯链表的形式时间复杂度为O(n)，红黑树则为O（logn），性能提升很大。什么时候链表转红黑树？当key值相等的元素形成的链表中元素个数超过8个的时候。当table一个下标下元素<6时，会从红黑树转换成链表

主要数据结构和关键变量

Node类存放实际的key和value值。

sizeCtl：

负数：表示进行初始化或者扩容,-1表示正在初始化，-N，表示有N-1个线程正在进行扩容

正数：0 表示还没有被初始化，>0的数，初始化或者是下一次进行扩容的阈值

TreeNode 用在红黑树，表示树的节点, TreeBin是实际放在table数组中的，代表了这个红黑树的根。

扩容操作

transfer()方法进行实际的扩容操作，table大小也是翻倍的形式，有一个并发扩容的机制。

size方法

估计的大概数量，不是精确数量

一致性

弱一致

ConcurrentSkipListMap 和 ConcurrentSkipListSet

TreeMap和TreeSet有序的容器，这两种容器的并发版本

跳表

SkipList，以空间换时间，在原链表的基础上形成多层索引，但是某个节点在插入时，是否成为索引，随机决定，所以跳表又称为概率数据结构。

ConcurrentLinkedQueue

无界非阻塞队列，底层是个链表，遵循先进先出原则

add,offer将元素插入到尾部，peek（拿头部的数据，但是不移除）和poll（拿头部的数据并移除）

CopyOnWriteArrayList、CopyOnWriteArraySet

写时复制容器

写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以写时复制容器也是一种读写分离的思想，读和写不同的容器。如果读的时候有多个线程正在向容器添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的，只能保证最终一致性。

与ReadWriteLock的区别:

ReadWriteLock在写时，会加锁对读、写线程都阻塞;

CopyOnWriteArrayList、CopyOnWriteArraySet是复制一个集合进行增加，不会对读有影响。

适用读多写少的并发场景，常见应用：白名单/黑名单，商品类目的访问和更新场景。

缺点:存在内存占用问题。

阻塞队列

概念

1)当队列满的时候，插入元素的线程被阻塞，直达队列不满。

2)队列为空的时候，获取元素的线程被阻塞，直到队列不空。

生产者和消费者模式

生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，便有了生产者和消费者模式。生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通信，而是通过阻塞队列来进行通信，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

常用方法

方法	抛出异常	返回值	一直阻塞	超时退出
插入方法	add	offer	put	Offer(time)
移除方法	remove	poll	take	Poll(time)
检查方法	element	peek	N/A	N/A

常用阻塞队列

·ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。

按照先进先出原则，要求设定初始大小

·LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。

照先进先出原则，可以不设定初始大小，默认Integer.Max_Value

ArrayBlockingQueue和LinkedBlockingQueue不同：

锁上面：ArrayBlockingQueue只有一个锁，LinkedBlockingQueue用了两个锁(存取)，
实现上：ArrayBlockingQueue直接插入元素，LinkedBlockingQueue需要转换。

·PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。

默认情况下，按照自然顺序，要么实现compareTo()方法，指定构造参数Comparator

·DelayQueue：一个使用优先级队列实现的无界阻塞队列。

支持延时获取的元素的阻塞队列，元素必须要实现Delayed接口。适用场景：实现自己的缓存系统，订单到期，限时支付等等。

·SynchronousQueue：一个不存储元素的阻塞队列。

每一个put操作都要等待一个take操作

·LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。

transfer()，必须要消费者消费了以后方法才会返回，tryTransfer()无论消费者是否接收，方法都立即返回。

·LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。

可以从队列的头和尾都可以插入和移除元素，实现工作密取，方法名带了First对头部操作，带了last从尾部操作，另外：add=addLast; remove=removeFirst; take=takeFirst

阻塞队列的实现原理

比如，ArrayBlockingQueue就是基于Lock和Condition实现的。

DelayQueue实现延时处理

Demo模式生产消费者模式，延迟时间到期后，才能被获取

/**
 * DelayQueue中存储的元素必须实现Delayed接口
 * @param <T>
 */
public class Item<T> implements Delayed {
    private long remainTime;//纳秒,设置Delay的到期时间
    private T item;

    public Item(long remainTime, T item) {
        this.remainTime = TimeUnit.MILLISECONDS.toNanos(remainTime) + System.nanoTime();
        this.item = item;
    }

    public long getRemainTime() {
        return remainTime;
    }

    public T getItem() {
        return item;
    }

    /**
     * getDelay方法表示多长时间后可以被获取，
     * 时间格式为 纳秒
     * @param unit
     * @return
     */
    @Override
    public long getDelay(TimeUnit unit) {
        //计算多少纳秒后到期
        return unit.convert(remainTime - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        long time = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return (time == 0) ? 0 : (time > 0 ? 1 : -1);
    }
}
public class Good {
    private String name;
    private long price;

    public Good(String name, long price) {
        this.name = name;
        this.price = price;
    }

    //省略get set
}
public class Produce extends Thread {
    private DelayQueue<Item<Good>> queue = new DelayQueue<>();

    public Produce(DelayQueue<Item<Good>> queue){
        this.queue = queue;
    }


    @Override
    public void run() {
        Good good = new Good("apple", 11);
        queue.offer(new Item<Good>(5000, good));
        System.out.println("订单5秒后到期："+ good.getName());

        Good good2 = new Good("banana", 50);
        queue.offer(new Item<Good>(8000, good));
        System.out.println("订单8秒后到期："+ good2.getName());
    }
}
public class Consumer extends Thread {
    private DelayQueue<Item<Good>> queue = new DelayQueue<>();

    public Consumer(DelayQueue<Item<Good>> queue){
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true){
            try {
                Item<Good> item = queue.take();
                Good good = item.getItem();
                System.out.println(good.getName() +" 获得订单");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<Item<Good>> queue = new DelayQueue<>();
        new Produce(queue).start();
        new Consumer(queue).start();

        //每隔500毫秒，打印个数字
        for(int i=1;i<20;i++){
            Thread.sleep(500);
            System.out.println(i*500);
        }
    }
}

运行结果:

订单5秒后到期：apple
订单8秒后到期：banana
500
1000
1500
2000
2500
3000
3500
4000
4500
5000
apple 获得订单
5500
6000
6500
7000
7500
8000
apple 获得订单
8500
9000
9500

naki_bb

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录