Collections.synchronizedList与CopyOnWriteArrayList比较

1.单线程方式

2.多线程版本，不安全的 ArrayList

3.多线程版本，线程安全，CopyOnWriteArrayList()方式

4.多线程版本，线程安全，Collections.synchronizedList方式

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author zsh
 * @site qqzsh.top
 * @create 2019-08-26 11:53
 * @description Collections.synchronizedList与CopyOnWriteArrayList比较
 * https://liuyanzhao.com/9732.html
 */
public class Main3 {

    /**
     * 单线程：性能较差
     */
    static void f1(){
        Long startTime = System.currentTimeMillis();
        //这是一个长度为1000的集合
        List<Long> sourceList = new ArrayList<>();
        for (long i = 0L; i < 1000L; i++) {
            sourceList.add(i);
        }
        System.out.println("原列表大小：" + sourceList.size());
        //对原列表进行处理
        List<Long> resultList = new ArrayList<>();
        for (Long x : sourceList) {
            //模拟耗时操作(x累加300万次)
            Long sum = 0L;
            for (long i = 0L; i < 3000000L; i++) {
                sum += x;
            }
            resultList.add(sum);
        }
        System.out.println("处理后的列表大小：" + resultList.size());
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime) + "ms");
    }

    /**
     * 多线程版本，不安全的 ArrayList
     */
    static void f2(){
        Long startTime = System.currentTimeMillis();
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        //这是一个长度为1000的集合
        List<Long> sourceList = new ArrayList<>();
        for (long i = 0L; i < 1000L; i++) {
            sourceList.add(i);
        }
        System.out.println("原列表大小：" + sourceList.size());
        List<Long> resultList = new ArrayList<>();
        for (Long x : sourceList) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //对原列表进行处理
                    //模拟耗时操作(x累加300万次)
                    Long sum = 0L;
                    for (long i = 0L; i < 3000000L; i++) {
                        sum += x;
                    }
                    resultList.add(sum);
                }
            });
        }
        fixedThreadPool.shutdown();//关闭线程池
        //此处不可以删除或注释，需要线程执行结束后再执行别的内容,即只有线程结束后才会继续向下执行
        while (!fixedThreadPool.isTerminated()) {
        }
        System.out.println("处理后的列表大小：" + resultList.size());
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime) + "ms");
    }

    /**
     * 多线程版本，线程安全，CopyOnWriteArrayList()方式
     */
    static void f3(){
        Long startTime = System.currentTimeMillis();
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        //这是一个长度为1000的集合
        List<Long> sourceList = new ArrayList<>();
        for (long i = 0L; i < 1000L; i++) {
            sourceList.add(i);
        }
        System.out.println("原列表大小：" + sourceList.size());
        List<Long> resultList = new CopyOnWriteArrayList<>();
        for (Long x : sourceList) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //对原列表进行处理
                    //模拟耗时操作(x累加300万次)
                    Long sum = 0L;
                    for (long i = 0L; i < 3000000L; i++) {
                        sum += x;
                    }
                    resultList.add(sum);
                }
            });
        }
        fixedThreadPool.shutdown();//关闭线程池
        //此处不可以删除或注释，需要线程执行结束后再执行别的内容,即只有线程结束后才会继续向下执行
        while (!fixedThreadPool.isTerminated()) {
        }
        System.out.println("处理后的列表大小：" + resultList.size());
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime) + "ms");
    }

    /**
     * 多线程版本，线程安全，Collections.synchronizedList方式
     */
    static void f4(){
        Long startTime = System.currentTimeMillis();
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        //这是一个长度为1000的集合
        List<Long> sourceList = new ArrayList<>();
        for (long i = 0L; i < 1000L; i++) {
            sourceList.add(i);
        }
        System.out.println("原列表大小：" + sourceList.size());
        List<Long> resultList = Collections.synchronizedList(new ArrayList<>());
        for (Long x : sourceList) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //对原列表进行处理
                    //模拟耗时操作(x累加300万次)
                    Long sum = 0L;
                    for (long i = 0L; i < 3000000L; i++) {
                        sum += x;
                    }
                    resultList.add(sum);
                }
            });
        }
        fixedThreadPool.shutdown();//关闭线程池
        //此处不可以删除或注释，需要线程执行结束后再执行别的内容,即只有线程结束后才会继续向下执行
        while (!fixedThreadPool.isTerminated()) {
        }
        System.out.println("处理后的列表大小：" + resultList.size());
        System.out.println("耗时：" + (System.currentTimeMillis() - startTime) + "ms");
    }

    public static void main(String[] args) {
        /*f1();*/
        /*f2();*/
        /*f3();*/
        f4();
    }
}