Collections.synchronizedList 集合线程安全

绝地灬酷狼 2022-05-24 00:00 172阅读 0赞

Collections.synchronizedList 是如何让一个集合变成线程安全的呢？为什么线程安全的集合效率非常低下？

![偷笑][titter.gif]那一定是你没有仔细查看实现源码。懒得找源码请直接看下文

// Synch Wrappers
 
 /**
 * Returns a synchronized (thread-safe) collection backed by the specified
 * collection. In order to guarantee serial access, it is critical that
 * all access to the backing collection is accomplished
 * through the returned collection.
 *
 * It is imperative that the user manually synchronize on the returned
 * collection when iterating over it:
 * <pre>
 * Collection c = Collections.synchronizedCollection(myCollection);
 * ...
 * synchronized (c) {
 * Iterator i = c.iterator(); // Must be in the synchronized block
 * while (i.hasNext())
 * foo(i.next());
 * }
 * </pre>
 * Failure to follow this advice may result in non-deterministic behavior.
 *
 * The returned collection does not pass the <tt>hashCode</tt>
 * and <tt>equals</tt> operations through to the backing collection, but
 * relies on <tt>Object</tt>'s equals and hashCode methods. This is
 * necessary to preserve the contracts of these operations in the case
 * that the backing collection is a set or a list.
 *
 * The returned collection will be serializable if the specified collection
 * is serializable.
 *
 * @param c the collection to be "wrapped" in a synchronized collection.
 * @return a synchronized view of the specified collection.
 */
 public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
 return new SynchronizedCollection<>(c);
 }

重点来了~

/**
 * @serial include
 */
 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;
 }
 
 public int size() {
 synchronized (mutex) {return c.size();}
 }
 public boolean isEmpty() {
 synchronized (mutex) {return c.isEmpty();}
 }
 public boolean contains(Object o) {
 synchronized (mutex) {return c.contains(o);}
 }
 public Object[] toArray() {
 synchronized (mutex) {return c.toArray();}
 }
 public <T> T[] toArray(T[] a) {
 synchronized (mutex) {return c.toArray(a);}
 }
 
 public Iterator<E> iterator() {
 return c.iterator(); // Must be manually synched by user!
 }
 
 public boolean add(E e) {
 synchronized (mutex) {return c.add(e);}
 }
 public boolean remove(Object o) {
 synchronized (mutex) {return c.remove(o);}
 }
 
 public boolean containsAll(Collection<?> coll) {
 synchronized (mutex) {return c.containsAll(coll);}
 }
 public boolean addAll(Collection<? extends E> coll) {
 synchronized (mutex) {return c.addAll(coll);}
 }
 public boolean removeAll(Collection<?> coll) {
 synchronized (mutex) {return c.removeAll(coll);}
 }
 public boolean retainAll(Collection<?> coll) {
 synchronized (mutex) {return c.retainAll(coll);}
 }
 public void clear() {
 synchronized (mutex) {c.clear();}
 }
 public String toString() {
 synchronized (mutex) {return c.toString();}
 }
 private void writeObject(ObjectOutputStream s) throws IOException {
 synchronized (mutex) {s.defaultWriteObject();}
 }
 }

通过以上源码可以知道，实现线程安全的方法就是暴力加锁，这效率能不低下吗？

当然，也不能说这代码有有啥问题，毕竟搞开发的，需求至上~

[titter.gif]: https://static-blog.csdn.net/xheditor/xheditor_emot/default/titter.gif