一、ArrayList、HashSet、HashMap线程不安全

1、ArrayList

public static void main(String[] args) {
//        List<String> arrayList = Arrays.asList("1", "2", "3");
        List<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                arrayList.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(arrayList);
            }).start();
        }
    }

运行后出现报错：java.util.ConcurrentModificationException

多线程高并发报错

1.导致原因

ArrayList是线程不安全的，add方法没有加synchronized关键字，所以add方法是线程不安全的，这时候对list操作，又要写又要读就导致了线程安全问题

2.解决方案

解决方案一：ArrayList的父类是Vector，而Vector是线程安全的。看源码可以得知其add方法是加了锁的，所以是线程安全。虽然他能够保证数据一致性，但是因为只能一个写或者一个读，导致它比较慢，性能差。

public static void main(String[] args) {
        List<String> list = new Vector<>();

        for (int i = 0; i <= 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }

解决方案二：使用Collections工具类，可以将一个线程不安全的ArrayList变成线程安全的。此方案小数据量的时候比较适合，大数据链参考以下方法。

public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());

        for (int i = 0; i <= 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }

解决方案三：可以使用JUC提供的CopyOnWriteArrayList，运用读写分离的思想，既能保证数据的一致性又能高性能。写的时候先进行复制，写的其实是一份新的复印件，原件可以进行集体的读。写完了之后unlock解锁，将新的复印件替换过去。

 public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 0; i <= 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }

查看源码，得知add方法的源码，往一个容器中添加元素的时候，不是直接往当前容器Object[]添加，而是先将当前容器Object[]进行copy，复制出一个新的容器Object[] newElements，然后新的容器Object [] newElements中添加元素，添加元素之后，再将原容器的引用指向新的容器setArray(newElements);这样做的好处是可以对CopyWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素，所以CopyOnWrite容器也是一种读写分离得思想。

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取到原来的版本
            Object[] elements = getArray();
            int len = elements.length;
            //  将原来的版本的数据复制过来，扩充一位
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

2、Set

public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        for (int i = 0; i <= 30; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }

运行后也出现报错：java.util.ConcurrentModificationException

一、解决方案同理：

//方案一：
Set<String> set = Collections.synchronizedSet(new HashSet<>());
//方案二：
Set<String> set = new CopyOnWriteArraySet<>();

二、HashSet的底层

HashSet的底层是HashMap，那为什么HashMap的put方法是两个值，而HashSet是add一个值呢，因为查看HashSet的源码可以得知，add方法实际上就是调用了HashMap的put方法，key就是add进去的值，而value永远都是一个Object类型的常量，也就是说所有HashSet的value都不重要

public HashSet() {
        map = new HashMap<>();
    }

3、Map

public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        for (int i = 0; i <= 30; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }

运行后也出现报错：java.util.ConcurrentModificationException

同样报错

一、解决方案同理：

//方案一：
Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
//方案二：
Map<String,String> map = new ConcurrentHashMap<>();

二、HashMap的底层

数组+链表+红黑树

散列表底层就是一个数组基础上做得完善，散列值通过散列函数，将key值转换成散列值存储在数组中，但是有时候会出现散列冲突的情况，也就是不同的key经过散列函数计算后生成了同一个散列值，这时候如果想要存储在数组中，发现存储空间就已经被占据了，于是采用一种链表法来解决散列冲突的问题，即在数组中存储一个“槽”，每个槽后面跟着一条链表，不同key得到相同的散列值，都存储在这条链表下，当链表长度不断的增长，直到长度到8，这条单向链表就会变成一条红黑树。

二、CountDownLatch

1、目的：五个同学加一个班长，同学们先走，班长最后走锁门

public class CountDownLatchDemo {

    public static void main(String[] args) {

        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "离开教室");
            }, String.valueOf(i)).start();

        }
        System.out.println(Thread.currentThread().getName()+"班长关门走人");
    }
}

结果

2、解决方法

public class CountDownLatchDemo {

    public static void main(String[] args) throws Exception{

        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "离开教室");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"班长关门走人");
    }
}

优化后结果

3、原理：

CountDownLatch主要有两个方法，当一个或多个线程用await方法时，这些线程会阻塞。其他线程调用countDown方法会将计数器减一（调用countDown方法的线程不会被阻塞），当计数器变为0时，因await方法阻塞的线程会被唤醒，继续执行。

三、CyclicBarrier

1、目的：收集七颗龙珠，然后才可以召唤神龙

public class CyclicBarrierDemo {

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("******召唤神龙");
        });

        for (int i = 1; i < 8; i++) {
            final int tem = i;

            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + ":收集到第" + tem + "个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

结果

四、Semaphore

1、目的：三个车位，七个车在抢，每个车停三秒钟

public class SemaphoreDemo {


    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);


        for (int i = 0; i < 7; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "停车成功");
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName() + "离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

2、结果

image.png

3、原理

在信号量的基础上定义两种操作：

acquire(获取)：当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
release(释放)：实际上会将信号量的值加一，然后唤醒等待的线程。

信号量主要用于两个目的，一个是用于多个共享资源的互斥作用，另一个是用于并发线程数的控制。如果将信号量设置为1，实际上也就相当于是给方法加synchornized。

五、ReadWriteLock

1、目的：多个线程同时读一个资源没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行 ，但是，如果有一个线程想去写公共资源，就不应该再有其他线程对他进行读或者写，读和写是否可以同时进行由我们自己来进行控制

读——读能共存
读——写不能共存
写——写不能共存

2、优化前

public class ReadWriteDemo {
    public static void main(String[] args) {

        MyCatch myCatch = new MyCatch();
        for (int i = 0; i < 5; i++) {
            final int temInt = i;
            new Thread(() -> {
                try {
                    myCatch.put(temInt + "", temInt + "");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int temInt = i;
            new Thread(() -> {
                myCatch.get(temInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

class MyCatch {
    HashMap<String, Object> map = new HashMap<>();
//    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) throws InterruptedException {
//        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "写入数据" + key);
        map.put(key, value);
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName() + "写入完成" + key);
//        readWriteLock.writeLock().unlock();
    }

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "读取数据");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
    }
}

运行结果如下所示，在0线程进行写入数据时，还没有写完，1线程就进来写数据了，违背了数据库的ACID，原子性，要么全部成功要么全部失败

运行结果

3、优化后

将注释掉的部分取消，开始写的时候进行了加锁，写完了之后释放锁，而读的时候则不加锁，运行结果如下

运行结果

六、BlockingQueue

1、简介：

在多线程领域：所谓阻塞，就是在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动唤起，使用BlockingQueue好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给办了。在concurrent包发布以前，在多线程环境下，程序员都需要自己去控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。

2、图解

image.png image.png 图解

如上所示，和常用的List，Set一样，Queue也是一个实现Collection的接口，Blocking实现Queue...

3、实现类

（重要）ArrayBlockingQueue:由数组结构组成的有界阻塞队列
（重要）LinkedBlockingQueue:由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列
PriorityBlockingQueue：支持优先级排序的无界阻塞队列
DelayQueue：使用优先级队列实现的延迟无界阻塞队列
（重要）SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列
LinkedTransferQueue：由链表组成的无界阻塞队列
LinkedBlockingDeque：由链表组成的双向阻塞队列。

4、核心方法

核心方法展示

public class BlockQueueDemo {
    public static void main(String[] args) {

        //====================第一组=====================
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println("add:" + blockingQueue.add("a"));//true
        System.out.println("add:" + blockingQueue.add("b"));//true
        System.out.println("add:" + blockingQueue.add("c"));//true
        //Exception in thread "main" java.lang.IllegalStateException: Queue full
//        System.out.println(blockingQueue.add("d"));//加了以上报错

        System.out.println("remove:" + blockingQueue.remove());
        System.out.println("remove:" + blockingQueue.remove());
        System.out.println("remove:" + blockingQueue.remove());
        //Exception in thread "main" java.util.NoSuchElementException
//        System.out.println("remove" + blockingQueue.remove());//加了以上报错

        //拿到的是队列中第一个元素，因为阻塞队列中已经没有数据了，所以会报错
        //Exception in thread "main" java.util.NoSuchElementException
//        System.out.println("element:" + blockingQueue.element());
//        System.out.println("element:" + blockingQueue.element());
//        System.out.println("element:" + blockingQueue.element());


        //====================第二组=====================
        BlockingQueue<String> blockingQueue2 = new ArrayBlockingQueue<>(2);

        System.out.println("offer:" + blockingQueue2.offer("1"));//true
        System.out.println("offer:" + blockingQueue2.offer("2"));//true
        System.out.println("offer:" + blockingQueue2.offer("3"));//false

        System.out.println("poll:" + blockingQueue2.poll());//1
        System.out.println("poll:" + blockingQueue2.poll());//2
        System.out.println("poll:" + blockingQueue2.poll());//null

        //====================第三组=====================
        BlockingQueue<String> blockingQueue3 = new ArrayBlockingQueue<>(2);
        try {
            blockingQueue3.put("a");
            blockingQueue3.put("b");
            //运行到这里会一直阻塞，直到put数据或者响应中断推出
//            blockingQueue3.put("c");
            System.out.println("take:" + blockingQueue3.take());
            System.out.println("take:" + blockingQueue3.take());
            //当队列为空时，试图从队列里take元素，对列会一直阻塞消费者线程直到队列可用
//            System.out.println("take:" + blockingQueue3.take());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        //====================第四组=====================
        BlockingQueue<String> blockingQueue4 = new ArrayBlockingQueue<>(2);
        try {
            blockingQueue4.offer("a", 1, TimeUnit.SECONDS);
            blockingQueue4.offer("b", 1, TimeUnit.SECONDS);
            //阻塞队列实际已满，队列会阻塞1s后退出此线程
            blockingQueue4.offer("c", 3, TimeUnit.SECONDS);
            System.out.println("poll:" + blockingQueue4.poll(1, TimeUnit.SECONDS));
            System.out.println("poll:" + blockingQueue4.poll(1, TimeUnit.SECONDS));
            //阻塞队列实际为空，队列会阻塞1s后退出此线程
            System.out.println("poll:" + blockingQueue4.poll(3, TimeUnit.SECONDS));

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}