Collections.synchronizedList(list) 把一个非线程安全的List转为线程安全的List。

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    5. public class Test {
    7.     public static void test() {
    9.         List list = new ArrayList();
    10.         List synchronizedList = Collections.synchronizedList(list);
    11.     }
    13. }

    Collections中部分源码

    1.     public static <T> List<T> synchronizedList(List<T> list) {
    2.         return (list instanceof RandomAccess ?
    3.                 new SynchronizedRandomAccessList<>(list) :
    4.                 new SynchronizedList<>(list));
    5.     }
    8.    static class SynchronizedList<E>
    9.         extends SynchronizedCollection<E>
    10.         implements List<E> {
    11.         private static final long serialVersionUID = -7754090372962971524L;
    13.         final List<E> list;
    15.         SynchronizedList(List<E> list) {
    16.             super(list);
    17.             this.list = list;
    18.         }
    19.         SynchronizedList(List<E> list, Object mutex) {
    20.             super(list, mutex);
    21.             this.list = list;
    22.         }
    24.         public boolean equals(Object o) {
    25.             if (this == o)
    26.                 return true;
    27.             synchronized (mutex) {return list.equals(o);}
    28.         }
    29.         public int hashCode() {
    30.             synchronized (mutex) {return list.hashCode();}
    31.         }
    33.         public E get(int index) {
    34.             synchronized (mutex) {return list.get(index);}
    35.         }
    36.         public E set(int index, E element) {
    37.             synchronized (mutex) {return list.set(index, element);}
    38.         }
    39.         public void add(int index, E element) {
    40.             synchronized (mutex) {list.add(index, element);}
    41.         }
    42.         public E remove(int index) {
    43.             synchronized (mutex) {return list.remove(index);}
    44.         }
    46.         public int indexOf(Object o) {
    47.             synchronized (mutex) {return list.indexOf(o);}
    48.         }
    49.         public int lastIndexOf(Object o) {
    50.             synchronized (mutex) {return list.lastIndexOf(o);}
    51.         }
    53.         public boolean addAll(int index, Collection<? extends E> c) {
    54.             synchronized (mutex) {return list.addAll(index, c);}
    55.         }
    57.         public ListIterator<E> listIterator() {
    58.             return list.listIterator(); // Must be manually synched by user
    59.         }
    61.         public ListIterator<E> listIterator(int index) {
    62.             return list.listIterator(index); // Must be manually synched by user
    63.         }
    65.         public List<E> subList(int fromIndex, int toIndex) {
    66.             synchronized (mutex) {
    67.                 return new SynchronizedList<>(list.subList(fromIndex, toIndex),
    68.                                             mutex);
    69.             }
    70.         }
    72.         @Override
    73.         public void replaceAll(UnaryOperator<E> operator) {
    74.             synchronized (mutex) {list.replaceAll(operator);}
    75.         }
    76.         @Override
    77.         public void sort(Comparator<? super E> c) {
    78.             synchronized (mutex) {list.sort(c);}
    79.         }
    81.         private Object readResolve() {
    82.             return (list instanceof RandomAccess
    83.                     ? new SynchronizedRandomAccessList<>(list)
    84.                     : this);
    85.         }
    86.     }

    其实就是用synchronized 同步代码块。