package mrzhang.juc.nien.chapter5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author zhangnianlei
 * @description
 * @date 2021/11/25
 */
public class ArrayListSecturyTest {

    // 线程池核心线程数
    private final static int THREAD_POOL_CORE_SIZE = 20;

    // 向数组中添加多少次
    private final static int COUNT = 10000000;


    public static void main(String[] args) throws InterruptedException {
        UnSafeArrayList();
        safeArrayList1();
        safeArrayList2();
        safeArrayList3();
    }

    private static void UnSafeArrayList() throws InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> list = new ArrayList(COUNT);
        // 创建一个线程池
        ExecutorService e = new ThreadPoolExecutor(THREAD_POOL_CORE_SIZE, THREAD_POOL_CORE_SIZE, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(COUNT));

        final CountDownLatch countSign = new CountDownLatch(COUNT);
        for (int i = 0; i < COUNT; i++) {
            final int finalI = i;
            e.execute(new Runnable() {
                public void run() {
                    try {
                        list.add(finalI);
                        countSign.countDown();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            });
        }
        countSign.await();
        e.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("不安全的版本");
        System.out.println(String.format("用时：%d ms", end - start));
        System.out.println(String.format("result: %d", list.size()));
        System.out.println();
    }

    private static void safeArrayList1() throws InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> list = new ArrayList(COUNT);
        // 创建一个线程池
        ExecutorService e = new ThreadPoolExecutor(THREAD_POOL_CORE_SIZE, THREAD_POOL_CORE_SIZE, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(COUNT));

        final CountDownLatch countSign = new CountDownLatch(COUNT);
        for (int i = 0; i < COUNT; i++) {
            final int finalI = i;
            e.execute(new Runnable() {
                public void run() {
                    synchronized (list) {
                        list.add(finalI);
                        countSign.countDown();
                    }
                }
            });
        }
        countSign.await();
        e.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("安全的版本 - 使用synchronize");
        System.out.println(String.format("用时：%d ms", end - start));
        System.out.println(String.format("result: %d", list.size()));
        System.out.println();
    }

    private static void safeArrayList2() throws InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> list = new ArrayList(COUNT);
        // 创建一个线程池
        ExecutorService e = new ThreadPoolExecutor(THREAD_POOL_CORE_SIZE, THREAD_POOL_CORE_SIZE, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(COUNT));

        final CountDownLatch countSign = new CountDownLatch(COUNT);
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < COUNT; i++) {
            final int finalI = i;
            e.execute(new Runnable() {
                public void run() {

                    lock.lock();
                    try {
                        list.add(finalI);
                        countSign.countDown();
                    } finally {
                        lock.unlock();
                    }
                }
            });
        }
        countSign.await();
        e.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("安全的版本 - 使用ReentrantLock");
        System.out.println(String.format("用时：%d ms", end - start));
        System.out.println(String.format("result: %d", list.size()));
        System.out.println();
    }

    private static void safeArrayList3() throws InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> list = Collections.synchronizedList(new ArrayList<>(COUNT));

        // 创建一个线程池
        ExecutorService e = new ThreadPoolExecutor(THREAD_POOL_CORE_SIZE, THREAD_POOL_CORE_SIZE, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(COUNT));

        final CountDownLatch countSign = new CountDownLatch(COUNT);
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < COUNT; i++) {
            final int finalI = i;
            e.execute(new Runnable() {
                public void run() {
                    list.add(finalI);
                    countSign.countDown();
                }
            });
        }
        countSign.await();
        e.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("安全的版本 - 使用Collections.synchronizedList(new ArrayList<>())");
        System.out.println(String.format("用时：%d ms", end - start));
        System.out.println(String.format("result: %d", list.size()));
        System.out.println();
    }

    private static void safeArrayList5() throws InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> list = new CopyOnWriteArrayList<>();
        // 创建一个线程池
        ExecutorService e = new ThreadPoolExecutor(THREAD_POOL_CORE_SIZE, THREAD_POOL_CORE_SIZE, 0L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(COUNT));

        final CountDownLatch countSign = new CountDownLatch(COUNT);
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < COUNT; i++) {
            final int finalI = i;
            e.execute(new Runnable() {
                public void run() {
                    list.add(finalI);
                    countSign.countDown();
                }
            });
        }
        countSign.await();
        e.shutdown();
        long end = System.currentTimeMillis();
        System.out.println("安全的版本 - 使用CopyOnWriteArrayList");
        System.out.println(String.format("用时：%d ms", end - start));
        System.out.println(String.format("result: %d", list.size()));
        System.out.println();
    }

}