集合线程安全控制-Collections工具类synchronizedXxx()方法

淡淡的烟草味﹌ 2022-05-09 06:12 173阅读 0赞

Vector 和 Hashtable都是古老的类,都是线程安全类。尽量少用Hashtable,Vector.

需要创建线程安全的List实现类，也无需使用Vector 实现类

需要创建线程安全的Map实现类，也无需使用Hashtable实现类。

可以使用Collections工具类把HashMap变成线程安全的。

Collections类提供了多个synchronizedXxx()方法，该方法可以将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

Java中常用的集合框架的实现类HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap和TreeMap都是线程不安全的。如果有多个线程试图修改它们,Collections提供了多个类方法可以把它们包装成线程同步的集合。

Collection c = Collections.synchronizedCollection(new ArrayList());
    List list = Collections.synchronizedList(new ArrayList());
    Set s = Collections.synchroniezedSet(new HashSet());
    Map m = Collections.synchronizedMap(new HashMap());

Collections类的synchronizedXxx()方法 是怎么样确保实现线程安全的呢？

class ListHelper <E> {  
        public List<E> list = Collections.synchronizedList(new ArrayList<E>());  
     
        public boolean putIfAbsent(E x) {  
            synchronized (list) {  
                boolean absent = !list.contains(x);  
                if (absent)  
                    list.add(x);  
                return absent;  
            }  
        } 
    }

public static <T> List<T> synchronizedList(List<T> list) {  
        return (list instanceof RandomAccess ?  
                    new SynchronizedRandomAccessList<T>(list) :  
                    new SynchronizedList<T>(list));  
        }

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList源码实现了RandomAccess，所以创建的应该是SynchronizedRandomAccessList类；

static class SynchronizedRandomAccessList<E>  extends SynchronizedList<E>  implements RandomAccess {  
            SynchronizedRandomAccessList(List<E> list) {  
                super(list);  
            }  
        SynchronizedRandomAccessList(List<E> list, Object mutex) {  
                super(list, mutex);  
            }  
        public List<E> subList(int fromIndex, int toIndex) {  
            synchronized(mutex) {  
                    return new SynchronizedRandomAccessList<E>(  
                        list.subList(fromIndex, toIndex), mutex);  
                }  
            }  
            static final long serialVersionUID = 1530674583602358482L;  
            private Object writeReplace() {  
                return new SynchronizedList<E>(list);  
            }  
        }

因为SynchronizedRandomAccessList这个类继承自SynchronizedList，而大部分方法都在SynchronizedList中实现了，所以源码中只包含了很少的方法，但是通过subList方法，我们可以看到这里使用的锁对象为mutex对象，而mutex是在SynchronizedCollection类中定义的，所以再看看SynchronizedCollection这个类中关于mutex的定义部分源码：

static class SynchronizedCollection<E> implements Collection<E>, Serializable {  
        private static final long serialVersionUID = 3053995032091335093L;  
        final Collection<E> c;  // Backing Collection  
        final Object mutex;     // Object on which to synchronize  
    
        SynchronizedCollection(Collection<E> c) {  
                if (c==null)  
                    throw new NullPointerException();  
            this.c = c;  
                mutex = this;  
            }  
    
        SynchronizedCollection(Collection<E> c, Object mutex) {  
            this.c = c;  
                this.mutex = mutex;  
            }  
    }

可以看到mutex就是当前的SynchronizedCollection对象，而SynchronizedRandomAccessList继承自SynchronizedList，SynchronizedList又继承自SynchronizedCollection，所以SynchronizedRandomAccessList中的mutex也就是SynchronizedRandomAccessList的this对象。所以在ListHelper类中使用的锁list对象和SynchronizedRandomAccessList内部的锁是一致的，所以它可以实现线程安全性。   -------》这部分参考博客https://www.cnblogs.com/yaowen/p/5983136.html

public static Map m = Collections.synchronizedMap(new HashMap());

Collections.synchronizedMap()会生成一个名为SynchronizedMap的Map,,它使用委托，将自己所有的Map相关的功能交给传入的

HashMap实现，而自己则主要负责保证线程安全。

首先SynchronizedMap内包装了一个Map;

private static class SynchronizedMap<K,V> implements Map<K,V>,Serializable{
    
       private static final long serialVersionUID = 1978198479659L;
       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可以满足线程安全的要求，但是，它在多线程环境中的性能表现并不太算好。无论是对Map的读取或写入，都需要获取mutex的锁，这会导致所有对Map的操作全部进入等待状态，直到mutex锁可用。如果并发级别不高，一般也够用。

但是在高并发环境中，就不适合，可以使用ConcurrentHashMap。

发表评论取消回复

表情：

评论列表（有 0 条评论，173人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java中的并发工具类：Collections.synchronizedXXX示例

在Java中，`Collections.synchronizedXXX`是用于同步容器操作的工具方法。这里XXX代表你要操作的集合，如List、Set等。以下是几个常见示例

我就是我/ 2024年10月21日 04:24/ 0 赞/ 49 阅读

相关线程安全的集合类

的方法，即当发现需要扩容时，创建一个新的数组，同时搬运几个元素过去，后续每次线程操作ConcurrentHashMap时，都会搬运元素，每次操作搬运一部分元素。，当读取顺...

柔情只为你懂/ 2024年04月25日 08:44/ 0 赞/ 133 阅读

相关 java——集合——Collections工具类——Collections集合工具类的方法——addAll&shuffle...

> Collection集合工具类的方法一 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public staticb

ゝ一纸荒年。/ 2024年03月31日 09:42/ 0 赞/ 92 阅读

相关 java——集合——Collections工具类——Collections集合工具类的方法——sort(List,Comparator)...

> Collection集合工具类的方法三 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public st

红太狼/ 2024年03月31日 09:42/ 0 赞/ 123 阅读

相关 java——集合——Collections工具类——Collections集合工具类的方法——sort(List)

> Collection集合工具类的方法二 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public staticvoi

小鱼儿/ 2023年09月28日 23:33/ 0 赞/ 27 阅读

相关 Java集合类线程安全

文章目录 ArrayList线程不安全 List线程安全解决方案 HashSet线程不安全 hashMap线程不安全 ArrayList

「爱情、让人受尽委屈。」/ 2022年09月06日 01:19/ 0 赞/ 253 阅读

相关 Collections.synchronizedList 集合线程安全

Collections.synchronizedList 是如何让一个集合变成线程安全的呢？为什么线程安全的集合效率非常低下？ ![偷笑][titter.gif]那一定是你没

绝地灬酷狼/ 2022年05月24日 00:00/ 0 赞/ 189 阅读

相关集合工具类：Collections

1.集合基本方法 ![70][] ![70 1][] ![70 2][] ![70 3][] 】![70 4][] ![70 5][] ![70 6]

古城微笑少年丶/ 2022年05月14日 13:21/ 0 赞/ 328 阅读

相关集合线程安全控制-Collections工具类synchronizedXxx()方法

Vector 和 Hashtable都是古老的类,都是线程安全类。尽量少用Hashtable,Vector. 需要创建线程安全的List实现类，也无需使用Vector 实现类

淡淡的烟草味﹌/ 2022年05月09日 06:12/ 0 赞/ 174 阅读

相关集合工具类（collection)

import org.springframework.util.CollectionUtils; import java.util.; imp

朱雀/ 2022年04月17日 05:21/ 0 赞/ 328 阅读