Java JUC并发知识详解

女爷i 2022-01-21 11:37 278阅读 0赞

### 今天夜里没啥事，想把java并发编程常用的JUC知识点都总结一点。我写博客开始的时间是2019/06/10 凌晨4:30，我就想说一句，你们见过凌晨四点的上海吗？ ###

### 预计会写这几个方面： ###

### 1.谈谈对volatile的理解 ###

### 2.CAS的介绍 ###

### 3.ABA问题 ###

### 4.线程安全的ArrayList的一些列解决方案 ###

### 5.java常见的锁（公/非平锁，可重入锁，自旋锁） ###

### 6.CountDownLatch/CyclicBarrier/Semaphore ###

### 7.阻塞队列 ###

### 8.线程池的详细原理介绍 ###

### 可以说这些问题基本上大厂面试都会或多或少的有一点，那面就让我们进入正题吧。 ###

# 1.谈谈对volatile的理解 #

详细看我这一篇博客的介绍[https://blog.csdn.net/oldshaui/article/details/89342858][https_blog.csdn.net_oldshaui_article_details_89342858]

# 2-3.CAS的介绍和ABA的问题 #

可以看我的博客：[https://blog.csdn.net/oldshaui/article/details/89432726][https_blog.csdn.net_oldshaui_article_details_89432726]

# 4.线程安全的ArrayList（set，map类似）的一些列解决方案 #

1.使用jdk1.0提供的vector（基本不用的方法）

2.使用Collections.synchronizedList(传入一个线程不安全的集合)（把list转换为一个安全的集合）

3.使用CopyOnWriteArrayList

介绍下CopyOnWriteArrayList

/**
         * 笔记
         * 写时复制 copyOnWrite 容器即写时复制的容器 往容器添加元素的时候,不直接往当前容器object[]添加,而是先将当前容器object[]进行
         * copy 复制出一个新的object[] newElements 然后向新容器object[] newElements 里面添加元素 添加元素后,
         * 再将原容器的引用指向新的容器 setArray(newElements);
         * 这样的好处是可以对copyOnWrite容器进行并发的读,而不需要加锁 因为当前容器不会添加任何容器.所以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();
         *         }
         *     }
         * @param args
         */

# 5.Java常见的几种锁 #

1.可重入锁

![20190610045025598.png][]

package cn.carryshuai.one.多线程.java的几种锁.可重入锁;
    class Phone{
        public synchronized void sendSms() throws Exception{
            System.out.println(Thread.currentThread().getName()+"\tsendSms");
            sendEmail();
        }
        public synchronized void sendEmail() throws Exception{
            System.out.println(Thread.currentThread().getName()+"\tsendEmail");
        }
    
    }
    /**
     * Description:
     *  可重入锁(也叫做递归锁)
     *  指的是同一先生外层函数获得锁后,内层敌对函数任然能获取该锁的代码
     *  在同一线程外外层方法获取锁的时候,在进入内层方法会自动获取锁
     *
     *  也就是说,线程可以进入任何一个它已经标记的锁所同步的代码块
     *
     * @author veliger@163.com
     * @date 2019-06-10 23:36
     **/
    public class ReenterLockDemo {
        /**
         * t1 sendSms
         * t1 sendEmail
         * t2 sendSms
         * t2 sendEmail
         * @param args
         */
        public static void main(String[] args) {
            Phone phone = new Phone();
            new Thread(()->{
                try {
                    phone.sendSms();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"t1").start();
            new Thread(()->{
                try {
                    phone.sendSms();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"t2").start();
        }
    }
    
    
    
    //执行结果
    t1	sendSms
    t1	sendEmail
    t2	sendSms
    t2	sendEmail

2.非/公平锁

![20190610045328867.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70][]

3.自旋锁

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1][]

package cn.carryshuai.one.多线程.java的几种锁.自旋锁;
    
    
    import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * 自旋锁：指定尝试获取锁的线程不会立即堵塞，而是采用循环的方式尝试获取锁，
     * 这样的好处就是减少了线程上下文的切换的消耗，缺点是循环会消耗cpu
     */
    public class OptionalDemo {
    
        private AtomicReference<Thread> atomicReference = new AtomicReference<>();
        public void lock(){
            System.out.println(Thread.currentThread() + " coming...");
            //如果期望是空的话，就设置为当前线程，跳出while循环
            while (!atomicReference.compareAndSet(null,Thread.currentThread())){
    
            }
        }
        public void unlock(){
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread,null);
            System.out.println(thread+"unlock；；；；；");
        }
    
        public static void main(String[] args) throws InterruptedException {
            OptionalDemo optionalDemo = new OptionalDemo();
            new Thread(()->{
                optionalDemo.lock();
                try {
                    Thread.sleep(1000);
                }catch (Exception e){
    
                }
                System.out.println("hahah");
                optionalDemo.unlock();
            }).start();
            Thread.sleep(1000);
            new Thread(() -> {
                optionalDemo.lock();
                System.out.println("hehehe");
                optionalDemo.unlock();
            }).start();
        }
    }

4.读写锁

![20190610045656727.png][]

package cn.carryshuai.one.多线程.java的几种锁.读写锁;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class ReentrantReadWriteLockDemo {
    
        public static void main(String[] args){
            Mycache mycache = new Mycache();
            for (int i = 0; i < 5; i++) {
                final int temp = i;
                new Thread(()->{
                    try {
                        mycache.put(temp+"",temp+"");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            for (int i = 0; i < 5; i++) {
                final int temp = i;
                new Thread(()->{
                    //读取数据
                    try {
                        mycache.get(temp+"");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }
    
    //一个缓存类
    class Mycache{
    
        private volatile Map<String,Object> map = new HashMap<>();
        //一个读写锁
        private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        //提供一个写的操作方法
        public void put(String key,Object value) throws Exception {
            //添加写锁
            ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
            try {
                writeLock.lock();
                System.out.println(Thread.currentThread().getName()+"正在写入："+key);
                //模拟睡眠
                Thread.sleep(1000);
                map.put(key,value);
                System.out.println(Thread.currentThread().getName()+"写入完成---");
    
            }finally {
                writeLock.unlock();
            }
        }
        //提供一个读取的方法
        public void get(String key) throws Exception {
            //添加一个读锁
            ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
            try {
                readLock.lock();
                System.out.println(Thread.currentThread().getName()+"正在读取---");
                //模拟睡眠
                Thread.sleep(1000);
                Object res = map.get(key);
                System.out.println(Thread.currentThread().getName() + " 读取完成，读取结果是 " + res);
            }finally {
                readLock.unlock();
            }
        }
    }

# 6.CountDownLatch/CyclicBarrier/Semaphore #

### CountDownLatch ###

让一些线程堵塞直到另一个线程完成一系列操作后才被唤醒。CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，调用线程会被堵塞，其他线程调用 countDown 方法会将计数减一（调用 countDown 方法的线程不会堵塞），当计数其值变为零时，因调用 await 方法被堵塞的线程会被唤醒，继续执行。

假设我们有这么一个场景，教室里有班长和其他6个人在教室上自习，怎么保证班长等其他6个人都走出教室在把教室门给关掉。

public class CountDownLanchDemo {
        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("班长把门给关了，离开了教室...");
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2][]

CyclicBarrier

![20190610050423505.png][]

举个集齐七龙珠，召唤神龙的例子

public class CyclicBarrierDemo {
        public static void main(String[] args) {
            CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
                System.out.println("召唤神龙");
            });
    
            for (int i = 1; i <=7; i++) {
                final int temp = i;
                new Thread(()->{
                 System.out.println(Thread.currentThread().getName()+"\t 收集到第"+ temp +"颗龙珠");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                },String.valueOf(i)).start();
            }
        }
    }

Semaphore

![20190610050700323.png][]

举个抢车位的例子

/**
     * Description
     *
     * @author veliger@163.com
     * @version 1.0
     * @date 2019-04-13 11:08
     **/
    public class SemaphoreDemo {
        public static void main(String[] args) {
            //模拟3个停车位
            Semaphore semaphore = new Semaphore(3);
            //模拟6部汽车
            for (int i = 1; i <= 6; i++) {
                new Thread(() -> {
                    try {
                        //抢到资源
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + "\t抢到车位");
                        try {
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "\t 停3秒离开车位");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //释放资源
                        semaphore.release();
                    }
                }, String.valueOf(i)).start();
            }
        }
    }

7.阻塞队列

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3][]

阻塞队列的好处

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 4][]

核心方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 5][]

8.线程池

线程池的好处：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 6][]

线程池的七大参数：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 7][]

线程池工作原理：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 9][]

[https_blog.csdn.net_oldshaui_article_details_89342858]: https://blog.csdn.net/oldshaui/article/details/89342858
[https_blog.csdn.net_oldshaui_article_details_89432726]: https://blog.csdn.net/oldshaui/article/details/89432726
[20190610045025598.png]: /images/20220121/8fa85cf84c724a3780175bc8e887e2fe.png
[20190610045328867.png]: /images/20220121/e2c89e614d1e430caaaea8b0c4f3f883.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70]: /images/20220121/77d389dab7c94389bc535ac65cc599e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 1]: /images/20220121/e649d4f838fe4b02a81d7716508bf861.png
[20190610045656727.png]: /images/20220121/dcbcf8a7187b4c8cb1aa6f02c8e24251.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 2]: /images/20220121/a6bf178935d34269bf2214e6a4611d47.png
[20190610050423505.png]: /images/20220121/ec03a434b7484a9faa9a590c05b796bf.png
[20190610050700323.png]: /images/20220121/f2060a99f507439691339dad9a996a4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 3]: /images/20220121/ac3a17afe5cb4d66ad7e15a5f7144744.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 4]: /images/20220121/9eb85a9483494e5b9e4ce731ffd5fe32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 5]: /images/20220121/6b74f5c027bb4d5f94d7c0f6d9ea2264.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 6]: /images/20220121/f00023c664c84e14af0e62ef3527d359.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 7]: /images/20220121/21594575bdf741d2a7b028069d522d98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 8]: /images/20220121/b74f1db2c5b144abb5cccd6b2129cf87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29sZHNoYXVp_size_16_color_FFFFFF_t_70 9]: /images/20220121/0148db3bca264c7ba538d95277e145e7.png