首页 技术 正文
技术 2022年11月15日
0 收藏 364 点赞 4,860 浏览 129227 个字

     除了提供诸如同步控制,线程池等基本工具外,为了提高开发人员的效率,JDK已经为我们准备了一大批好用的并发容器,这些容器都是线程安全的,可以大大减少开发工作量。你可以在里面找到链表、HashMap、队列等。你可以在里面找到链表、HashMap、队列等。 JDK提供的这些容器大部分在java.util.con-current包中。   •ConcurrentHashMap:这是一个高效的并发HashMap。你可以理解为一个线程安全的HashMap。   •CopyOnWriteArrayList:这是一个List,从名字看就是和ArrayList是一族的。在读多写少的场合,这个List的性能非常好,远远好于Vector。   •ConcurrentLinkedQueue:高效的并发队列,使用链表实现。可以看做一个线程安全的LinkedList。   •BlockingQueue:这是一个接口,JDK内部通过链表、数组等方式实现了这个接口。表示阻塞队列,非常适合用于作为数据共享的通道。   •ConcurrentSkipListMap:跳表的实现。这是一个Map,使用跳表的数据结构进行快速查找。     除了以上并发包中的专有数据结构外,java.util下的Vector是线程安全的(虽然性能和上述专用工具没得比),另外Collections工具类可以帮助我们将任意集合包装成线程安全的集合。 一.在多线程环境中使用HashMap  1.一种可行的方法是使用Collections.synchronizedMap()方法包装我们的HashMap      public static Map m=Collections.synchronizedMap(new HashMap());    Collections.synchronizedMap()会生成一个名为SynchronizedMap的Map。它使用委托,将自己所有Map相关的功能交给传入的HashMap实现,而自己则主要负责保证线程安全。     SynchronizedMap内包装了一个mapprivate static class SynchronizedMap<K,V>        implements Map<K,V>, Serializable {        private static final long serialVersionUID = 1978198479659022715L;        private final Map<K,V> m;     // Backing Map        final Object      mutex;        // Object on which to synchronize    通过mutex实现对这个m的互斥操作。比如,对于Map.get()方法,它的实现如下:public V get(Object key) {    synchronized (mutex) {        return m.get(key);}}    而其他所有相关的Map操作都会使用这个mutex进行同步。从而实现线程安全。这会导致所有对Map的操作全部进入等待状态,直到mutex锁可用。如果并发级别不高,一般也够用。但是,在高并发环境中,我们也有必要寻求新的解决方案。     2.一个更加专业的并发HashMap是ConcurrentHashMap。它位于java.util.concurrent包内。它专门为并发进行了性能优化,因此,更加适合多线程的场合。 二、在多线程环境中使用List    参考前面对HashMap的包装,在这里我们也可以使用   1. Collections. synchronizedList()方法来包装任意List,如下所示:public static List<String> l=Collections.synchronizedList(new LinkedList<String>());    此时生成的List对象就是线程安全的。   2.vector    三、高效读写的队列:ConcurrentLinkedQueue    ConcurrentLinkedQueue应该算是在高并发环境中性能最好的队列就可以了。它之所有能有很好的性能,是因为其内部复杂的实现。        对Node进行操作时,使用了CAS操作。boolean casItem(E cmp, E val) {    return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);}void lazySetNext(Node<E> val) {    UNSAFE.putOrderedObject(this, nextOffset, val);}boolean casNext(Node<E> cmp, Node<E> val) {    return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);}     方法casItem()表示设置当前Node的item值。它需要两个参数,第一个参数为期望值,第二个参数为设置目标值。当当前值等于cmp期望值时,就会将目标设置为val。同样casItem()方法也是类似的,但是它是用来设置next字段,而不是item字段    ConcurrentLinkedQueue内部有两个重要的字段,head和tail,分别表示链表的头部和尾部,它们都是Node类型。对于head来说,它永远不会为null,并且通过head以及succ()后继方法一定能完整地遍历整个链表。对于tail来说,它自然应该表示队列的末尾。 该队列特点:    1.tail的更新会产生滞后,并且每次更新会跳跃两个元素。     2.线程安全完全由CAS操作和队列的算法来保证。整个方法的核心是for循环,这个循环没有出口,直到尝试成功,这也符合CAS操作的流程。     3. p = (t != (t = tail)) ? t : head;         这句代码虽然只有短短一行,但是包含的信息比较多。首先“!=”并不是原子操作,它是可以被中断的。也就是说,在执行“!=”是,程序会先取得t的值,再执行t=tail,并取得新的t的值。然后比较这两个值是否相等。在单线程时,t!=t这种语句显然不会成立。但是在并发环境中,有可能在获得左边的t值后,右边的t值被其他线程修改。这样,t!=t就可能成立。这里就是这种情况。如果在比较过程中,tail被其他线程修改,当它再次赋值给t时,就会导致等式左边的t和右边的t不同。如果两个t不相同,表示tail在中途被其他线程篡改。这时,我们就可以用新的tail作为链表末尾,也就是这里等式右边的t。但如果tail没有被修改,则返回head,要求从头部开始,重新查找尾部。              /**入队操作*/     public boolean offer(E e) {         checkNotNull(e);        final Node<E> newNode = new Node<E>(e);         for (Node<E> t = tail, p = t;;) {            Node<E> q = p.next;            if (q == null) {                // p 是最后一个节点                if (p.casNext(null, newNode)) {                     //每2次,更新一下tail                    if (p != t) // hop two nodes at a time                        casTail(t, newNode);  // Failure is OK.                    return true;                }                // Lost CAS race to another thread; re-read next            }            else if (p == q)                    //遇到哨兵节点,从都head开始遍历。                 //但如果tail被修改,则使用tail(因为可能被修改正确了)                p = (t != (t = tail)) ? t : head;            else                 // 取下一个节点或者最后一个节点                p = (p != t && t != (t = tail)) ? t : q;        }    }     /**弹出队列操作*/ public E poll() {    restartFromHead:    for (;;) {        for (Node<E> h = head, p = h, q;;) {            E item = p.item;             if (item != null && p.casItem(item, null)) {                // Successful CAS is the linearization point                // for item to be removed from this queue.                if (p != h) // hop two nodes at a time                    updateHead(h, ((q = p.next) != null) ? q : p);                return item;            }            else if ((q = p.next) == null) {                updateHead(h, p);  //将head设置为哨兵                return null;            }            else if (p == q)                continue restartFromHead;            else                p = q;        }    }} final void updateHead(Node<E> h, Node<E> p) {    if (h != p && casHead(h, p))        h.lazySetNext(h);} 四、高效读取的数组:CopyOnWriteArrayList    为了将读取的性能发挥到极致,JDK中提供了CopyOnWriteArrayList类。对它来说,读取是完全不用加锁的,并且更好的消息是:写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来,读操作的性能就会大幅度提升。    所谓CopyOn-Write就是在写入操作时,进行一次自我复制。换句话说,当这个List需要修改时,我并不修改原有的内容(这对于保证当前在读线程的数据一致性非常重要),而是对原有的数据进行一次复制,将修改的内容写入副本中。写完之后,再将修改完的副本替换原来的数据。这样就可以保证写操作不会影响读了。     读取实现:private volatile transient Object[] array; public E get(int index) {    return get(getArray(), index);} final Object[] getArray() {    return array;} private E get(Object[] a, int index) {    return (E) a[index];}     写实现:public boolean add(E e) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            int len = elements.length;            Object[] newElements = Arrays.copyOf(elements, len + 1);            newElements[len] = e;            setArray(newElements);            return true;        } finally {            lock.unlock();        }    }    首先,写入操作使用锁,当然这个锁仅限于控制写-写的情况。其重点在于进行了内部元素的完整复制。因此,会生成一个新的数组newElements。然后,将新的元素加入newElements。接着,使用新的数组替换老的数组,修改就完成了。整个过程不会影响读取,并且修改完后,读取线程可以立即“察觉”到这个修改(因为array变量是volatile类型)。 五、数据共享通道:BlockingQueue    ConcurrentLinkedQueue作为高性能的队列。对于并发程序而言,高性能自然是一个我们需要追求的目标。但多线程的开发模式还会引入一个问题,那就是如何进行多个线程间的数据共享呢?比如,线程A希望给线程B发一个消息,用什么方式告知线程B是比较合理的呢?    BlockingQueue是一个接口,实现类如下图:    其中ArrayBlockingQueue是基于数组实现的,而LinkedBlockingQueue基于链表。也正因为如此,ArrayBlockingQueue更适合做有界队列,因为队列中可容纳的最大元素需要在队列创建时指定(毕竟数组的动态扩展不太方便)。而LinkedBlock-ingQueue适合做无界队列,或者那些边界值非常大的队列,因为其内部元素可以动态增加,它不会因为初值容量很大,而一口气吃掉你一大半的内存。    线程是如何知道队列中来了下一条消息的?一种是线程按照一定的时间间隔不停地循环和监控这个队列,这是可行的,但是造成了不必要的资源浪费。而BlockingQueue之所有适合作为数据共享的通道,其关键还在于Blocking上,BlockingQueue很好地解决了这个问题。它会让服务线程在队列为空时,进行等待,当有新的消息进入队列后,自动将线程唤醒     工作模式如下:     ArrayBlockingQueue的内部元素都放置在一个对象数组中:        final Object[] items;    1.向队列中压入元素可以使用offer()方法和put()方法。对于offer()方法,如果当前队列已经满了,它就会立即返回false。如果没有满,则执行正常的入队操作。我们需要关注的是put()方法。put()方法也是将元素压入队列末尾。但如果队列满了,它会一直等待,直到队列中有空闲的位置。    2.从队列中弹出元素可以使用poll()方法和take()方法。它们都从队列的头部获得一个元素。不同之处在于:如果队列为空poll()方法直接返回null,而take()方法会等待,直到队列内有可用元素。     因此,put()方法和take()方法才是体现Blocking的关键。    在ArrayBlockingQueue内部定义了以下一些字段:        final ReentrantLock lock;        private final Condition notEmpty;            private final Condition notFull;    当执行take()操作时,如果队列为空,则让当前线程等待在notEmpty上。新元素入队时,则进行一次notEmpty上的通知。     下面的代码显示了take()的过程:     public E take() throws InterruptedException {        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0)                notEmpty.await();            return dequeue();        } finally {            lock.unlock();        }    }     private E dequeue() {        // assert lock.getHoldCount() == 1;        // assert items[takeIndex] != null;        final Object[] items = this.items;        @SuppressWarnings(“unchecked”)        E x = (E) items[takeIndex];        items[takeIndex] = null;        if (++takeIndex == items.length)            takeIndex = 0;        count–;        if (itrs != null)            itrs.elementDequeued();        notFull.signal();        return x;    }     下面是元素入队的代码:        public void put(E e) throws InterruptedException {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == items.length)                notFull.await();            enqueue(e);        } finally {            lock.unlock();        }    }     private void enqueue(E x) {        // assert lock.getHoldCount() == 1;        // assert items[putIndex] == null;        final Object[] items = this.items;        items[putIndex] = x;        if (++putIndex == items.length)            putIndex = 0;        count++;        notEmpty.signal();    }    当新元素进入队列后,需要通知等待在notEmpty上的线程,让他们继续工作。同理,对于put()操作也是一样的,当队列满时,需要让压入线程等待  六、随机数据结构:跳表(SkipList)    在JDK的并发包中,除了常用的哈希表外,还实现了一种有趣的数据结构——跳表。跳表是一种可以用来快速查找的数据结构,有点类似于平衡树。它们都可以对元素进行快速的查找。但一个重要的区别是:对平衡树的插入和删除往往很可能导致平衡树进行一次全局的调整。而对跳表的插入和删除只需要对整个数据结构的局部进行操作即可。这样带来的好处是:在高并发的情况下,你会需要一个全局锁来保证整个平衡树的线程安全。而对于跳表,你只需要部分锁即可。这样,在高并发环境下,你就可以拥有更好的性能。而就查询的性能而言,跳表的时间复杂度也是O(logn)。所以在并发数据结构中,JDK使用跳表来实现一个Map。    跳表的另外一个特点是随机算法。跳表的本质是同时维护了多个链表,并且链表是分层的,如图<img src="data:image/png;base64,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" alt="" width="440">    最低层的链表维护了跳表内所有的元素,每上面一层链表都是下面一层的子集,一个元素插入哪些层是完全随机的。因此,如果你运气不好的话,你可能会得到一个性能很糟糕的结构。但是在实际工作中,它的表现是非常好的。    跳表内的所有链表的元素都是排序的。查找时,可以从顶级链表开始找。一旦发现被查找的元素大于当前链表中的取值,就会转入下一层链表继续找。这也就是说在查找过程中,搜索是跳跃式的    在跳表中查找元素7。查找从顶层的头部索引节点开始。由于顶层的元素最少,因此,可以快速跳跃那些小于7的元素。很快,查找过程就能到元素6。由于在第2层,元素8大于7,故肯定无法在第2层找到元素7,故直接进入底层(包含所有元素)开始查找,并且很快就可以根据元素6搜索到元素7。整个过程,要比一般链表从元素1开始逐个搜索快很多。如图:    <img src="data:image/png;base64,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" alt="" width="427">    因此,很显然,跳表是一种使用空间换时间的算法。     使用跳表实现Map和使用哈希算法实现Map的另外一个不同之处是:哈希并不会保存元素的顺序,而跳表内所有的元素都是排序的。因此在对跳表进行遍历时,你会得到一个有序的结果。所以,如果你的应用需要有序性,那么跳表就是你不二的选择。     实现这一数据结构的类是ConcurrentSkipListMap     和HashMap不同,对跳表的遍历输出是有序的。     跳表的内部实现有几个关键的数据结构组成。    1.首先是Node,一个Node就是表示一个节点    static final class Node<K,V> {        final K key;        volatile Object value;        volatile Node<K,V> next;    对Node的所有更新操作,使用的是CAS方法:        /**         * compareAndSet value field         */        boolean casValue(Object cmp, Object val) {            return UNSAFE.compareAndSwapObject(this, valueOffset, cmp, val);        }         /**         * compareAndSet next field         */        boolean casNext(Node<K,V> cmp, Node<K,V> val) {            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);        }    方法casValue()用来设置value的值,相对的casNext()用来设置next的字段。     2.另外一个重要的数据结构是Index。顾名思义,这个表示索引。它内部包装了Node,同时增加了向下的引用和向右的引用。    static class Index<K,V> {        final Node<K,V> node;        final Index<K,V> down;        volatile Index<K,V> right;    整个跳表就是根据Index进行全网的组织的。     3.此外,对于每一层的表头,还需要记录当前处于哪一层。为此,还需要一个称为HeadIndex的数据结构,表示链表头部的第一个Index。它继承自Index。     /**     * Nodes heading each level keep track of their level.     */    static final class HeadIndex<K,V> extends Index<K,V> {        final int level;        HeadIndex(Node<K,V> node, Index<K,V> down, Index<K,V> right, int level) {            super(node, down, right);            this.level = level;        }    }  核心内部元素就这三个,对于跳表的所有操作,就是组织好这些Index之间的连接关系。                 

相关推荐
python开发_常用的python模块及安装方法
adodb:我们领导推荐的数据库连接组件bsddb3:BerkeleyDB的连接组件Cheetah-1.0:我比较喜欢这个版本的cheeta…
日期:2022-11-24 点赞:878 阅读:9,030
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接:http://www.codeforces.com/contest/660/problem/CDes…
日期:2022-11-24 点赞:807 阅读:5,520
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
日期:2022-11-24 点赞:569 阅读:6,368
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
日期:2022-11-24 点赞:733 阅读:6,148
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式,并且由于涉及到要把拍到的照片显…
日期:2022-11-24 点赞:512 阅读:7,781
Struts的使用
一、Struts2的获取  Struts的官方网站为:http://struts.apache.org/  下载完Struts2的jar包,…
日期:2022-11-24 点赞:671 阅读:4,859