同步容器 示例（一）Vector

同步容器概述

• 同步容器中的方法主要采用synchronized进行同步，这势必会影响性能；
• 同步容器并不一定能做到完全的线程安全；
• 并发容器是可以取代同步容器的；
• 实际变成中，同步容器的使用场景已经越来越少了；

同步容器举例

• ArrayList -> Vector，Stack；
• HashMap -> HashTable，其key，value不能为空；
• Collections.synchronizedXXX（List, Set, Map）；

Vector要点

• 同步容器Vector不等同于就是线程安全的；

同步容器Vector示例

• 多线程并发累加Vector中的值不会出现问题；

import com.example.concurrency.annotations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.List;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
@ThreadSafe
public class VectorExample1 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    private static List<Integer> list = new Vector<>();

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal; i++) {
            final int count = i;
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}", list.size());
    }

    private static void update(int i) {
        list.add(i);
    }

}

输出：

10:13:37.348 [main] INFO com.example.concurrency.example.safecontainer.VectorExample1 - size:5000

多线程导致的Vector问题1

• vector.size()，vector.remove(i)，vector.get(i)都是同步方法，但当是线程2走到i=9时，线程1切入，运行vector.remove(9)，再切回线程1时运行vector.get(9)，已经被线程1删掉的索引9上的数据，就会导致数组越界；
• 在这种场合下，调用处要做一些额外的同步处理；
• 这种写法就属于先检查（判断）再执行；

import com.example.concurrency.annotations.NotThreadSafe;

import java.util.Vector;

@NotThreadSafe
public class VectorExample2 {

    private static Vector<Integer> vector = new Vector<>();

    public static void main(String[] args) {
        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }

            Thread thread1 = new Thread() {
                public void run() {
                    for (int i = 0; i < vector.size(); i++) {
                        vector.remove(i);
                    }
                }
            };

            Thread thread2 = new Thread() {
                public void run() {
                    for (int i = 0; i < vector.size(); i++) {
                        vector.get(i);
                    }
                }
            };
            thread1.start();
            thread2.start();
        }
    }

}

输出：

Exception in thread "Thread-433" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 14
at java.util.Vector.get(Vector.java:748)
at com.example.concurrency.example.safecontainer.VectorExample22.run(VectorExample2.java:29)

多线程导致的Vector问题2

• 遍历期间修改Vector中的值，只能用for(int i = 0; i < vector.size(); i++)，使用foreach和iterator会抛出异常；
• 可以在遍历的时候只标记出要修改的值，在遍历结束后再统一修改；

import java.util.Iterator;
import java.util.Vector;

public class VectorExample3 {

    // java.util.ConcurrentModificationException
    private static void test1(Vector<Integer> v1) { // foreach
        for(Integer i : v1) {
            if (i.equals(3)) {
                v1.remove(i);
            }
        }
    }

    // java.util.ConcurrentModificationException
    private static void test2(Vector<Integer> v1) { // iterator
        Iterator<Integer> iterator = v1.iterator();
        while (iterator.hasNext()) {
            Integer i = iterator.next();
            if (i.equals(3)) {
                v1.remove(i);
            }
        }
    }

    // success
    private static void test3(Vector<Integer> v1) { // for
        for (int i = 0; i < v1.size(); i++) {
            if (v1.get(i).equals(3)) {
                v1.remove(i);
            }
        }
    }

    public static void main(String[] args) {

        Vector<Integer> vector = new Vector<>();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        test1(vector);
    }
}

抛出的异常：

Exception in thread "main" java.util.ConcurrentModificationException
at java.util.VectorItr.next(Vector.java:1137)
at com.example.concurrency.example.safecontainer.VectorExample3.test2(VectorExample3.java:21)
at com.example.concurrency.example.safecontainer.VectorExample3.main(VectorExample3.java:43)