美文网首页
多线程学习(JUC)

多线程学习(JUC)

作者: 西谷haul | 来源:发表于2021-01-25 22:09 被阅读0次

一、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();
        }
    }
}

相关文章

网友评论

      本文标题:多线程学习(JUC)

      本文链接:https://www.haomeiwen.com/subject/petwzktx.html