集合的线程安全解读

1. public class NotSafeDemo {
2. 
3. /**
4.      * 多个线程同时对集合进行修改
5.      * @param args
6.      */
7. public static void main(String[] args) {
8. List list = new ArrayList();
9. 
10. for (int i = 0; i < 100; i++) {
11. new Thread(() ->{
12.                 list.add(UUID.randomUUID().toString());
13.                 System.out.println(list);
14.             }, "线程" + i).start();
15.         }
16.     }
17. }

1. /** 
2. 
3. * Appends the specified element to the end of this list. 
4. * @param e element to be appended to this list 
5. * @return <tt>true</tt> (as specified by {@link Collection#add}) 
6. */
7. 
8. public boolean add(E e) { 
9.  ensureCapacityInternal(size + 1); // Increments modCount!! 
10.  elementData[size++] = e; 
11. return true; 
12. }

1. public class NotSafeDemo {
2. 
3. /**
4.      * 多个线程同时对集合进行修改
5.      *
6.      * @param args
7.      */
8. public static void main(String[] args) {
9. List list = new Vector();
10. 
11. for (int i = 0; i < 100; i++) {
12. new Thread(() -> {
13.                 list.add(UUID.randomUUID().toString());
14.                 System.out.println(list);
15.             }, "线程" + i).start();
16.         }
17.     }
18. }

1. /** 
2. 
3. * Appends the specified element to the end of this Vector. 
4. * @param e element to be appended to this Vector 
5. * @return {@code true} (as specified by {@link Collection#add}) 
6. * @since 1.2 
7. */
8. 
9. public synchronized boolean add(E e) { 
10.  modCount++; 
11.  ensureCapacityHelper(elementCount + 1); 
12.  elementData[elementCount++] = e; 
13. return true; 
14. 
15. }

1. public class NotSafeDemo {
2. 
3. /**
4.      * 多个线程同时对集合进行修改
5.      *
6.      * @param args
7.      */
8. public static void main(String[] args) {
9. List list = Collections.synchronizedList(new ArrayList<>());
10. for (int i = 0; i < 100; i++) {
11. new Thread(() -> {
12.                 list.add(UUID.randomUUID().toString());
13.                 System.out.println(list);
14.             }, "线程" + i).start();
15.         }
16.     }
17. }

1. /** 
2. 
3. * Returns a synchronized (thread-safe) list backed by the specified 
4. * list. In order to guarantee serial access, it is critical that 
5. * <strong>all</strong> access to the backing list is accomplished 
6. * through the returned list.<p> 
7. * 
8. * It is imperative that the user manually synchronize on the returned 
9. * list when iterating over it: 
10. * <pre> 
11. * List list = Collections.synchronizedList(new ArrayList()); 
12. * ... 
13. * synchronized (list) { 
14. * Iterator i = list.iterator(); // Must be in synchronized block 
15. * while (i.hasNext()) 
16. * foo(i.next()); 
17. * } 
18. * </pre> 
19. * Failure to follow this advice may result in non-deterministic behavior. 
20. * 
21. * <p>The returned list will be serializable if the specified list is 
22. * serializable. 
23. * 
24. * @param <T> the class of the objects in the list 
25. * @param list the list to be "wrapped" in a synchronized list. 
26. * @return a synchronized view of the specified list. 
27. */
28. 
29. public static <T> List<T> synchronizedList(List<T> list) { 
30. return (list instanceof RandomAccess ? 
31. new SynchronizedRandomAccessList<>(list) : 
32. new SynchronizedList<>(list)); 
33. }

1. public class NotSafeDemo {
2. 
3. /**
4.      * 多个线程同时对集合进行修改 
5.      * @param args
6.      */
7. public static void main(String[] args) {
8. List list = new CopyOnWriteArrayList();
9. for (int i = 0; i < 100; i++) {
10. new Thread(() ->{
11.                 list.add(UUID.randomUUID().toString());
12.                 System.out.println(list);
13.             }, "线程" + i).start();
14.         }
15.     }
16. }