尚硅谷JUC笔记

素颜马尾好姑娘i 2023-01-03 04:43 232阅读 0赞

### JUC ###

*   *  第一集：JUC介绍
     *   *  1、面试常见问题类别
         *  2、JUC是什么？
         *  3、回顾进程和线程
     *  第二集：卖票复习
     *   *  1、多线程编程的企业级套路+模板
         *   *  1).最重要的三句话
             *  2).第一句话的例子
             *  3).第二句话、第三句话的例子
             *  4).精准通知顺序操作(为什么要用Lock取代synchronized的原因)
             *  5).lambda表达式写法
     *  第三集：8锁的现象
     *  第四集：不安全的ArrayList
     *   *  1、ArrayList不安全吗？
         *  2、ArrayList不安全怎么办？
         *   *  方案1：使用Vector类(不采用)
             *  方案2：使用Collections.synchronizedList(new ArrayList<>())（适合低并发小数据量的时候使用）
             *  方案3：使用CopyOnWriteArrayList代替ArrayList（适合多线程高并发大数据量的时候使用）
     *  第五集：不安全的HashSet
     *   *  1、HashSet不安全吗？
         *  2、HashSet不安全怎么办？
         *   *  方案1：使用Collections.synchronizedSet(new HashSet<>())（适合低并发小数据量的时候使用）
             *  方案2：使用CopyOnWriteArraySet代替HashSet（适合多线程高并发大数据量的时候使用）
     *  第六集：不安全的HashMap
     *   *  1、HashMap不安全吗？
         *  2、HashMap不安全怎么办？
         *   *  方案1：使用HashTable（不采用）
             *  方案2：使用Collections.synchronizedMap(new HashMap<>())（适合低并发小数据量的时候使用）
             *  方案3：使用ConcurrentHashMap代替HashMap（适合多线程高并发大数据量的时候使用）
     *  第七集：Callable
     *  第八集：CountDownLatch
     *  第九集：CyclicBarrier
     *  第十集：Semaphore
     *  第十一集：ReentrantReadWriteLock
     *  第十二集：BlockingQueue
     *  第十三集：线程池的三大方法
     *  第十四集：ThreadPoolExecutor的底层原理
     *  第十五集：四大函数式接口
     *  第十六集：流式编程
     *  第十七集：ForkJoin例子
     *  第十八集：CompletableFuture例子
     *  第十九集：Volatile关键字
     *  第二十集：原子类

## 第一集：JUC介绍 ##

### 1、面试常见问题类别 ###

*  面向对象、高级语法（1、抽象类和接口有什么区别？2、Java中获得多线程有几种方法？）
 *  Java集合类（1、java.util.\*中的ArrayList、Vector、LinkedList、TreeMap、HashSet、HashMap、ConcurrentHashMap、CopyOnWriteHashMap、Queue等？2、谈谈你对HashMap的理解，什么是Hash算法，什么是Hash碰撞？）
 *  Java多线程（1、Java中获得多线程的方法有几种？）
 *  Java IO 和 NIO

### 2、JUC是什么？ ###

![在这里插入图片描述][20210107150017823.png]

简单来说JUC就是java.util.concurrent并发包

### 3、回顾进程和线程 ###

**1).进程和线程是什么？**

答：进程是计算机分配资源的基本单位，它是一个具有独立功能的程序，例如QQ运行起来就是一个大的进程，这可以在任务管理器中看到；线程是程序执行的最小单位，一个进程里面可以有很多个线程，这些线程共享进程中的资源。

**2).进程和线程举例？**

答：例如QQ运行起来就是一个大的进程，然后里面有天气预报，我们可以同时进行文字聊天和视频，这些都是小的线程

**3).线程状态？**

答： [JVM中的线程状态][JVM]

**4).wait和sleep的区别？**

答：wait睡眠的时候会放开手中的锁，而sleep睡眠的时候会带着手中的锁，wait和sleep都可以设置睡眠时间，那他们的线程进入的是`TIMED_WAITING`状态，如果wait不设置睡眠时间，那需要使用其他方法使用`共享对象.notify()`或者`共享对象.notifyAll()`方法唤醒，并且进入的是`WAITING`状态

**5).并发和并行分别是什么？**

答：并发：同一时刻多个线程访问同一个资源，例如：例子：小米9限量抢购、春运抢票、电商秒杀…  
并行：同一时刻多个线程同时访问不同资源

## 第二集：卖票复习 ##

### 1、多线程编程的企业级套路+模板 ###

#### 1).最重要的三句话 ####

1.  在高内聚低耦合的前提下，线程 操作（资源类中对外暴露的方法） 资源类
2.  先判断，然后干活，最后通知
3.  在多线程交互中，必须要防止多线程的虚假唤醒，也即判断只能用while，不能用if

#### 2).第一句话的例子 ####

**题目：**

三个售票员 卖出 30张票

**使用synchronized编写代码：**

// 资源类
    class Ticket { 
        // 共享资源
        private int number = 30;
        
        // 操作
        public synchronized void saleTicket() { 
            if (number > 0) { 
                System.out.println(Thread.currentThread().getName() + "卖出了第" + number-- + "张票");
            }
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            // 创建资源类
            Ticket ticket = new Ticket();
            // 创建线程
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "A").start();
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "B").start();
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "C").start();
        }
    }

**使用synchronized编写代码的解释：**

由于结果太长，所以就不给大家看了，我们创建了`Ticket资源类`，里面放着共享资源`number`，并且资源类中包含着操作`saleTicket()`，然后我们在main()方法中创建资源类对象，然后创建线程A、B、C同时去利用`Ticket资源类对象`调用`saleTicket()`，当然了`saleTicket()`方法上加的有`synchronized`关键字，由于A、B、C线程操作的都是同一个`Ticket资源类对象`，所以`synchronized`关键字锁住的就是该对象，因此不会出现多卖票的问题

**使用Lock锁编写代码：**

// 资源类
    class Ticket { 
        // 共享资源
        private int number = 30;
        // 创建锁
        private final Lock lock = new ReentrantLock();
    
        // 操作
        public void saleTicket() { 
            // 加锁
            lock.lock();
            try { 
                // 业务代码
                if (number > 0) { 
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + number-- + "张票");
                }
            } finally { 
                // 解锁
                lock.unlock();
            }
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            // 创建资源类
            Ticket ticket = new Ticket();
            // 创建线程
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "A").start();
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "B").start();
            new Thread(() -> { for (int i = 0; i < 40; i++) ticket.saleTicket();}, "C").start();
        }
    }

**使用Lock锁编写代码的解释：**

加锁之后锁的不是某个对象，而是锁的这段代码，也就是说同一时刻有且只能有一个线程来执行加锁的这段代码，不过记着finally中解锁，使用finally的目的是为了保证在业务代码发生异常的时候依然可以解锁成功。其实这种做法和`synchronized(this){***}`还是有很多相似之处的，但是synchronized同步锁还是需要锁着线程共享的东西，比如前面写的this代表共享对象ticket，只要锁着的是多个线程共享的东西就可以了

#### 3).第二句话、第三句话的例子 ####

**题目：**

现在有四个线程去操作一个初始值为0的变量，要求实现其中两个线程对该变量加1，另外两个线程对该变量减1，要求变量的值只能是0和1，并且要进行交替展示，每个线程来10轮操作

**使用synchronized、wait、notifyAll来解决问题的代码：**

// 资源类
    class Resource { 
        private int number = 0;
        // 加1操作
        @SneakyThrows // 不用抛出异常
        public synchronized void increase() { 
            // 判断
            while (number == 1) { 
                this.wait();
            }
            // 干活
            number++;
            System.out.println(Thread.currentThread().getName() + "：" + number);
            // 通知
            this.notifyAll();
        }
        // 减1操作
        @SneakyThrows
        public synchronized void decrease() { 
            // 判断
            while (number == 0) { 
                this.wait();
            }
            // 干活
            number--;
            System.out.println(Thread.currentThread().getName() + "：" + number);
            // 通知
            this.notifyAll();
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            // 创建资源类对象
            Resource resource = new Resource();
            // A线程和B线程加
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.increase();}, "A").start();
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.increase();}, "B").start();
            // C线程和D线程加
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.decrease();}, "C").start();
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.decrease();}, "D").start();
        }
    }

**使用synchronized、wait、notifyAll来解决问题的代码解释：**

4个线程中两个加1两个减1，那肯定要在加1操作方法和减1操作方法中判断是否要进行加1或者减1，如果不加1或者减1的话那就要把同步锁让出来给其他线程，因此我们需要判断是否应该执行这个操作，如果不符合条件的话那就需要使用wait()方法睡眠，如果符合条件那就干活，干完活后唤醒其他线程，其他线程在开始争抢cpu时间片，至于为什么使用while而不用if判断呢？我来给你解释，现在假设A线程执行第一次判断发现可以加，那number就变成了1，之后唤醒其他线程，假设当A线程释放锁之后B线程抢到了锁，然后他一判断不能做蛋糕，那就执行wait()方法，假设当B线程释放锁之后A线程抢到了锁，然后他一判断还是不能做蛋糕，那就执行wait()方法，假设A线程释放锁之后C线程获得了锁，她属于顾客，然后她取走了一个蛋糕，那number就变成了0，之后唤醒其他线程，假设当C线程释放锁之后A线程获得了锁，然后A线程生产蛋糕，number就变成了1，之后唤醒其他线程，假设当A线程释放锁之后B线程抢到了锁，如果使用的是if判断，由于之前B线程执行了wait()方法，那它会从wait()方法之后执行，那么B先生会继续做蛋糕，这就违背了题目要求，所以不能使用if，而是应该使用while，假设还是上面的情况，即当A线程释放锁之后B线程抢到了锁，如果使用的是while判断，那就会在经过一次判断，一经判断发现number是1，那就不能做蛋糕，还是只能执行wait()方法，所以使用while判断可以完美解决虚假唤醒问题

**使用Lock、await、signalAll来解决问题的代码：**

// 资源类
    class Resource { 
        private int number = 0;
        private final Lock lock = new ReentrantLock();
        private final Condition condition = lock.newCondition();
    
        // 加1操作
        @SneakyThrows // 不用抛出异常
        public void increase() { 
            // 加锁
            lock.lock();
            try { 
                // 判断
                while (number == 1) { 
                    condition.await();
                }
                // 干活
                number++;
                System.out.println(Thread.currentThread().getName() + "：" + number);
                // 通知
                condition.signalAll();
            } finally { 
                lock.unlock();
            }
        }
    
        // 减1操作
        @SneakyThrows
        public void decrease() { 
            // 加锁
            lock.lock();
            try { 
                // 判断
                while (number == 0) { 
                    condition.await();
                }
                // 干活
                number--;
                System.out.println(Thread.currentThread().getName() + "：" + number);
                // 通知
                condition.signalAll();
            } finally { 
                lock.unlock();
    
            }
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            // 创建资源类对象
            Resource resource = new Resource();
            // A线程和B线程加
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.increase();}, "A").start();
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.increase();}, "B").start();
            // C线程和D线程加
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.decrease();}, "C").start();
            new Thread(() -> { for (int i = 0; i < 10; i++)resource.decrease();}, "D").start();
        }
    }

**使用Lock、await、signalAll来解决问题的代码的解释：**

之前用wait()和notifyAll()来做的，现在用`private final Condition condition = lock.newCondition();`创建出来的condition调用await()和signalAll()来做，作用都是一样的，只不过之前的`synchronized、wait、notifyAll铁三角`换成了`Lock、await、signalAll铁三角`

#### 4).精准通知顺序操作(为什么要用Lock取代synchronized的原因) ####

**题目：**

多线程之间严格按照顺序调用，实现A线程—》B线程—》C线程，当三个线程启动之后，要求如下：

AA打印5次，BB打印10次，CC打印15次  
接着  
AA打印5次，BB打印10次，CC打印15次  
……一共来10轮

**代码：**

// 资源类
    class Resource { 
        private int number = 1;
        private final Lock lock = new ReentrantLock();
        // condition1、condition2、condition3分别对应线程AA、BB、CC
        private final Condition condition1 = lock.newCondition();
        private final Condition condition2 = lock.newCondition();
        private final Condition condition3 = lock.newCondition();
    
        @SneakyThrows // 不用抛出异常
        public void print(int size) { 
            lock.lock();
            try { 
                // 判断
                if (size == 5) { 
                    while (number != 1) { 
                        condition1.await();
                    }
                }
                if (size == 10) { 
                    while (number != 2) { 
                        condition2.await();
                    }
                }
                if (size == 15) { 
                    while (number != 3) { 
                        condition3.await();
                    }
                }
                // 干活
                for (int i = 1; i <= size; i++) { 
                    System.out.println(Thread.currentThread().getName()+"："+i);
                }
                // 精准通知
                if (size == 5) { 
                    number = 2;
                    condition2.signal();
                }
                if (size == 10) { 
                    number = 3;
                    condition3.signal();
                }
                if (size == 15) { 
                    number = 1;
                    condition1.signal();
                }
            } finally { 
                lock.unlock();
            }
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            // 创建资源类对象
            Resource resource = new Resource();
            // 创建多个线程
            new Thread(()->{ for (int i = 0; i < 10;i++) resource.print(5); },"AA").start();
            new Thread(()->{ for (int i = 0; i < 10;i++) resource.print(10); },"BB").start();
            new Thread(()->{ for (int i = 0; i < 10;i++) resource.print(15); },"CC").start();
        }
    }

**解释：**

完美实现效果，可以创建多个Condition类进行操作，实现精准通知，如果使用synchronized铁三角就无法实现相同的效果

#### 5).lambda表达式写法 ####

**一句话：**

复制小括号，写死右箭头，落地大括号

**解释：**

首先只有函数式接口中的方法才能使用Lambda表达式，而函数式接口就是方法中有且仅有一个方法需要被实现，但是里面还可以有default修饰的方法或者static修饰的静态方法是不影响的，毕竟它们不需要被实现，当然如果接口符合函数式接口的限制条件，并且该接口想成为函数式接口，最好在接口名称上面加上`@FunctionalInterface`注解，一方面可以表明本接口是函数式接口，另外一方面还可以验证当前接口是否符合函数式接口的约束条件，例如`Runnable`接口就是函数式接口；复制小括号就是复制那个被实现的方法中的()，例如`Runnable`接口中的`public abstract void run();`中的()，写死右箭头就是在小括号后面写上`->`，落地大括号就是最后写一个`{}`；最后说明lambda表达式的作用就是简写匿名内部类

**例子：**

// 使用匿名内部类实现接口
    new Thread(new Runnable() { 
        @Override
        public void run() { 
            System.out.println("我是一个线程");
        }
    }).start();
    // 使用Lambda表达式改写匿名内部类
    new Thread(() -> { System.out.println("我是一个线程"); }).start();}

**代码解释：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70]  
当然只有一条语句的时候，大括号可以省略，另外还有一些其他的规则，例如小括号中有参数的时候可以省略参数类型，如果只有一个参数不仅可以省略参数类型，还可以省略包裹参数的小括号，还有如果只有一条代码的话还可以省略大括号，如果这行代码是return返回值代码不仅可以省略大括号，还可以省略return关键字，直接在`->`后面写上返回值就可以了，更多细节请看：[Lambda表达式详解][Lambda]

## 第三集：8锁的现象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 1]  
**解释：**

其实做对这些问题需要了解这么一些事情，首先对象锁和类锁是不一样的，如果一个方法上加了synchronized，那使用的是对象锁，如果一个方法上加了static和synchronized，那使用的是类锁，然后对象锁锁的是一个对象，如果同一个类中的多个方法上加的仅仅有synchronized，并且同一时刻多个线程使用某对象去运行同步方法，但是只会有一个线程运行同步方法，其他线程都要等待；如果同一个类中的多个方法上加的有static和synchronized，那获得的锁就是类锁，类锁也叫做静态同步锁，当然类锁只关注同一个类中同时加的有static和synchronized的那些方法，另外我还想说对象锁和类锁是不同的，他们互不影响，他们是两个锁，没有从属关系，一个线程获得类锁的同时，另外一个线程可以获得对象锁，如果上述所说的类中的方法上没有加synchronized，也没有加static，那就不需要获得对象锁或者类锁，多少个线程同时去调用这些方法都是没有错的；另外还需要知道sleep()方法代表执行该方法的线程是带着锁睡的，醒来的时候线程依然带着锁

## 第四集：不安全的ArrayList ##

### 1、ArrayList不安全吗？ ###

**问题：**

请举例说明ArrayList不是线程安全的？

**代码：**

public class Test { 
        public static void main(String[] args) { 
            List<String> list = new ArrayList<>();
            for (int i = 1; i < 100; i++) { 
                new Thread(() -> { 
                    // 写入
                    list.add(UUID.randomUUID().toString().substring(0, 8));
                    // 读出
                    System.out.println(list);
                }, String.valueOf(i)).start();
            }
        }
    }

**说明：**

会出现`java.util.ConcurrentModificationException`，该异常俗称`并发修改异常`，即多个线程需要写入，同时还有多个线程还要读出，所以会出现该异常

### 2、ArrayList不安全怎么办？ ###

#### 方案1：使用Vector类(不采用) ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、ArrayList不安全吗？”中的测试代码相同
    List<String> list = new Vector<>();

**说明：**

加了synchronized，读取效率太低

#### 方案2：使用Collections.synchronizedList(new ArrayList<>())（适合低并发小数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、ArrayList不安全吗？”中的测试代码相同
    List<String> list = Collections.synchronizedList(new ArrayList<>());

**说明：**

可以把线程不安全的ArrayList对象变成线程安全的对象，其实就是对ArrayList中的每个方法上加synchronized

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 2]  
现在来解释一下里面的原理，我们点进synchronizedList()方法，代码如下：

public static <T> List<T> synchronizedList(List<T> list) { 
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

由于`list`是`new ArrayList<>()`，所以`instanceof`判断结果是`false`，所以执行`new SynchronizedList<>(list)`，我们点击`SynchronizedList`进去看一下，代码如下：

static class SynchronizedCollection<E> implements Collection<E>, Serializable { 
    	private static final long serialVersionUID = 3053995032091335093L;
    
    	final Collection<E> c;  // Backing Collection
    	final Object mutex;     // Object on which to synchronize
    	………………
    }
    
    static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> { 
    	private static final long serialVersionUID = -7754090372962971524L;
    
    	// list就是new ArrayList<>()
    	final List<E> list;
    
    	SynchronizedList(List<E> list) { 
    		super(list);
    		this.list = list;
    	}
    	// 使用synchronized同步代码块来保证原子性操作
    	public void add(int index, E element) { 
    		synchronized (mutex) { list.add(index, element);}
    	}
    }

可以看到代码中用到了synchronized同步代码块，因此会保证操作的原子性

#### 方案3：使用CopyOnWriteArrayList代替ArrayList（适合多线程高并发大数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、ArrayList不安全吗？”中的测试代码相同
    List<String> list = new CopyOnWriteArrayList<>();

**说明：**

这是写时复制思想， 首先看add()方法中有可重入锁，这个目的是防止多个线程争抢写的权力，然后下面红框中的内容是将原件复制出来一份，然后在复印件上写，之后通过setArray()方法让原件地址指向复印件，这样可以让所有人读原件，而我只修改复印件，所以读和写不会出现冲突，因此通过加锁和写时复制思想可以很好保证了多线程情况下所有线程都可以读，但是只有一个线程在写，因此不会出现并发修改异常，如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 3]  
以上是说自己的解释，以下是老师的解释：![在这里插入图片描述][20210222124022816.png]

## 第五集：不安全的HashSet ##

### 1、HashSet不安全吗？ ###

**问题：**

请举例说明HashSet不是线程安全的？

**代码：**

public class Test { 
        public static void main(String[] args) { 
            Set<String> set = new HashSet<>();
            for (int i = 1; i < 100; i++) { 
                new Thread(() -> { 
                    // 写入
                    set.add(UUID.randomUUID().toString().substring(0, 8));
                    // 读出
                    System.out.println(set);
                }, String.valueOf(i)).start();
            }
        }
    }

**说明：**

会出现`java.util.ConcurrentModificationException`，该异常俗称`并发修改异常`，即多个线程需要写入，同时还有多个线程还要读出，所以会出现该异常  
另外还需要说明的一点是HashSet的底层是HashMap，可以看源码：

![在这里插入图片描述][20210107213545576.png]  
然而HashMap的底层是Hash表，Hash表是数组加单向链表的组成结构

### 2、HashSet不安全怎么办？ ###

#### 方案1：使用Collections.synchronizedSet(new HashSet<>())（适合低并发小数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、HashSet不安全吗？”中的测试代码相同
    Set<String> set = Collections.synchronizedSet(new HashSet<>());

**说明：**

可以把线程不安全的HashSet对象变成线程安全的对象，其实就是对HashSet中的每个方法上加synchronized

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 4]

#### 方案2：使用CopyOnWriteArraySet代替HashSet（适合多线程高并发大数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、HashSet不安全吗？”中的测试代码相同
    Set<String> set = new CopyOnWriteArraySet<>();

**说明：**

首先`CopyOnWriteArraySet`的`add()`方法：

![在这里插入图片描述][20210107212716869.png]  
然后点击addIfAbsent()就到了**CopyOnWriteArrayList类**中：

![在这里插入图片描述][20210107212800119.png]  
之后我们点击`addIfAbsent()`方法后发现**CopyOnWriteArrayList类**中的该方法内部代码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 5]

## 第六集：不安全的HashMap ##

### 1、HashMap不安全吗？ ###

**问题：**

请举例说明HashMap不是线程安全的？

**代码：**

public class Test { 
        public static void main(String[] args) { 
            Map<String, String> map = new HashMap<>();
            for (int i = 1; i < 100; i++) { 
                new Thread(() -> { 
                    // 写入
                    map.put(UUID.randomUUID().toString().substring(0, 8), UUID.randomUUID().toString().substring(0, 8));
                    // 读出
                    System.out.println(map);
                }, String.valueOf(i)).start();
            }
        }
    }

**说明：**

会出现`java.util.ConcurrentModificationException`，该异常俗称`并发修改异常`，即多个线程需要写入，同时还有多个线程还要读出，所以会出现该异常

### 2、HashMap不安全怎么办？ ###

#### 方案1：使用HashTable（不采用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、HashMap不安全吗？”中的测试代码相同
    Map<String, String> map = new Hashtable<>();

**说明：**

加了synchronized，读取效率太低，一次锁整张Hash表，相当于这个表是表锁，只要当前线程在读或者写，其他线程都不能进行操作，虽然解决了并发问题，但是相当于将并行操作变成了串行操作，另外在进行复合操作的时候也不是线程安全的，比如添加操作是判断是否存在和添加的联合操作，我们不期待这个过程在别人打扰，但是两个子操作中间是有可能被别人打扰的，可能我判断的时候没有这个值，但是在我执行添加操作之前被别人添加上了，然后我再去添加的时候发现有人已经添加了，这不就是添了个寂寞吗，说明添加操作就不是线程安全的

#### 方案2：使用Collections.synchronizedMap(new HashMap<>())（适合低并发小数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、HashMap不安全吗？”中的测试代码相同
    Map<String, String> map = Collections.synchronizedMap(new HashMap<>());

**说明：**

可以把线程不安全的HashMap对象变成线程安全的对象，其实就是对HashMap中的每个方法上加synchronized  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 6]

#### 方案3：使用ConcurrentHashMap代替HashMap（适合多线程高并发大数据量的时候使用） ####

**举例：**

// 除了这一行之外，其他代码的和上面“1、HashMap不安全吗？”中的测试代码相同
    Map<String, String> map = new ConcurrentHashMap<>();

**说明：**

在JDK1.7中，ConcurrentHashMap里面使用的是锁分段机制，默认ConcurrentLevel分段级别是16，也就是说默认有16个段Segment段，每个段上有一个锁，每个段后面都是一个哈希表，这样每次就有16个锁了，我们每次操作的是不同的锁，这样比HashTable中的1个锁要好多了，至少不是串行操作了

在jdk1.8中，ConcurrentHashMap取消了分段锁机制（锁分段机制也是一样的意思，都可以用，没有区别），底层使用CAS算法，CAS算法根本没有使用锁，它使用的是while循环判断，如果修改成功那就结束while循环，否则只要依然有CPU时间片，那就继续执行修改操作，直到执行成功为止，由于JVM为Unsafe类中的CAS方法写成汇编指令，虽然CAS中涉及到获取比较交换三个操作，但是这三个操作是原子操作，中途不会被打断，所以CAS操作是原子性的，并且没有锁，效率更高，由于一直在while循环中，所以会减少线程上下文切换的消耗，但是循环也会带来一些时间开销

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 7]

## 第七集：Callable ##

**代码：**

class MyThread implements Callable<Integer> { 
        @Override
        public Integer call() throws Exception { 
            System.out.println("hello MyThread!");
            TimeUnit.SECONDS.sleep(4);
            return 1024;
        }
    }
    
    public class Test { 
        public static void main(String[] args) throws Exception { 
            FutureTask futureTask = new FutureTask(new MyThread());
            new Thread(futureTask, "A").start();
            System.out.println(futureTask.get());
            System.out.println("hello Test!");
        }
    }

**解释：**

首先输出`hello MyThread!`，经过4秒中之后输出`1024`，然后输出`hello Test!`，说明get()方法会阻塞调用该方法的线程，比如本次阻塞的就是主线程，因此我们最好将get()方法往后放，等到主线程中的其他操作完成的时候在通过get()方法获取返回值，毕竟尽量少等会是最好的选择，其实我们都知道Thread类的构建方法中的两个参数其中的第一个参数是Runnable接口，如果我们想使用Runnable接口，那我们需要Callable接口和Runnable接口挂上钩，具体关联如下：

![在这里插入图片描述][2021010722172765.png]  
**Callable接口和Runnable的不同：**

*  名称不同
 *  重写方法不同，Callable中是call()方法，而Runnable中是run()方法
 *  是否带泛型，其中Callable接口带有泛型，而Runnable接口不带有泛型
 *  是否有返回值，其中Callable接口有返回值，返回值类型和泛型类型一致
 *  构建方式不同，其中Callable接口用的是FutureTask类作为媒介来联系上Runnable接口

## 第八集：CountDownLatch ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            CountDownLatch countDownLatch = new CountDownLatch(6);
            for (int i = 1; i <= 6; i++) { 
                new Thread(()->{ 
                    System.out.println(Thread.currentThread().getName()+"号学生离开教室");
                    countDownLatch.countDown();
                },String.valueOf(i)).start();
            }
            countDownLatch.await();
            System.out.println("所有学生走完，关门");
        }
    }

**结果：**

1号学生离开教室
    6号学生离开教室
    5号学生离开教室
    4号学生离开教室
    3号学生离开教室
    2号学生离开教室
    所有学生走完，关门

**解释：**

`CountDownLatch countDownLatch = new CountDownLatch(6);`代表只有执行6次`countDownLatch.countDown();`之后总量变成0，执行一次`countDownLatch.countDown();`就少一个1，然后`countDownLatch.await();`表示在等待着6变成0的时候，只要变成了0，那么`System.out.println("所有学生走完，关门");`就会执行

## 第九集：CyclicBarrier ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> System.out.println("7颗龙珠聚齐，开始召唤神龙！"));
            for (int i = 1; i <= 7; i++) { 
                final int finalI = i;
                new Thread(() -> { 
                    System.out.println(Thread.currentThread().getName() + "号收集到第" + finalI + "颗龙珠");
                    try { 
                        cyclicBarrier.await();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) { 
                        e.printStackTrace();
                    }
                }, String.valueOf(i)).start();
            }
        }
    }

**结果：**

2号收集到第2颗龙珠
    3号收集到第3颗龙珠
    4号收集到第4颗龙珠
    1号收集到第1颗龙珠
    5号收集到第5颗龙珠
    6号收集到第6颗龙珠
    7号收集到第7颗龙珠
    7颗龙珠聚齐，开始召唤神龙！

**解释：**

之前说的`CountDownLatch`是每次减去1，而本次是执行一次`await()`方法就加一个1，加到7，那就可以执行`CyclicBarrier`中的第二个参数中的线程了

## 第十集：Semaphore ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            Semaphore semaphore = new Semaphore(3);
            for (int i = 1; i <= 6; i++) { 
                new Thread(()->{ 
                    try { 
                        // 获得信号量
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()+"号车主抢到了车位");
                        // 暂停一会线程，表示占据车位的过程
                        TimeUnit.SECONDS.sleep(3);
                        System.out.println(Thread.currentThread().getName()+"号车主离开了车位");
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    } finally { 
                        // 释放信号量
                        semaphore.release();
                    }
                },String.valueOf(i)).start();
            }
        }
    }

**结果：**

3号车主抢到了车位
    1号车主抢到了车位
    2号车主抢到了车位
    2号车主离开了车位
    1号车主离开了车位
    3号车主离开了车位
    4号车主抢到了车位
    5号车主抢到了车位
    6号车主抢到了车位
    4号车主离开了车位
    5号车主离开了车位
    6号车主离开了车位

**解释：**

一共准备了3个车位，也就是信号量构造方法中的3，然后有6个车主去抢车位，当3个车主抢到车位之后，另外几位车主只能等待，当有车主移出车位之后其他车主才可以抢车位，其中我们所说的车主就是一个一个的线程

## 第十一集：ReentrantReadWriteLock ##

**代码：**

class MyCache { 
        private volatile Map<String,Object> map = new HashMap<>();
        private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        // 写入数据
        @SneakyThrows
        public void put(String key, Object value) { 
            readWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName()+"号线程写入数据开始，key="+key);
                map.put(key, value);
                // 模拟程序执行过程，但是不会出现多次连续写
                TimeUnit.MICROSECONDS.sleep(100);
                System.out.println(Thread.currentThread().getName()+"号线程写入数据结束，key="+key);
            } finally { 
                readWriteLock.writeLock().unlock();
            }
        }
    
        // 读出数据
        @SneakyThrows
        public void get(String key) { 
            readWriteLock.readLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName()+"号线程读出数据开始，key="+key);
                Object o = map.get(key);
                // 模拟程序执行过程，可以出现多次连续读
                TimeUnit.MICROSECONDS.sleep(100);
                System.out.println(Thread.currentThread().getName()+"号线程读出数据结束，key="+key);
            } finally { 
                readWriteLock.readLock().unlock();
            }
        }
    }
    
    public class Test { 
        public static void main(String[] args) throws Exception { 
            MyCache myCache = new MyCache();
            for (int i = 1; i <= 5; i++) { 
                int finalI = i;
                new Thread(()->{ myCache.put(String.valueOf(finalI), String.valueOf(finalI));},String.valueOf(i)).start();
            }
            for (int i = 6; i <= 10; i++) { 
                int finalI = i;
                new Thread(()->{ myCache.get(String.valueOf(finalI-5));},String.valueOf(finalI)).start();
            }
        }
    }

**结果：**

1号线程写入数据开始，key=1
    1号线程写入数据结束，key=1
    3号线程写入数据开始，key=3
    3号线程写入数据结束，key=3
    2号线程写入数据开始，key=2
    2号线程写入数据结束，key=2
    4号线程写入数据开始，key=4
    4号线程写入数据结束，key=4
    5号线程写入数据开始，key=5
    5号线程写入数据结束，key=5
    6号线程读出数据开始，key=1
    7号线程读出数据开始，key=2
    8号线程读出数据开始，key=3
    10号线程读出数据开始，key=5
    9号线程读出数据开始，key=4
    7号线程读出数据结束，key=2
    9号线程读出数据结束，key=4
    8号线程读出数据结束，key=3
    10号线程读出数据结束，key=5
    6号线程读出数据结束，key=1

**解释：**

一个线程加上写锁，那其他的线程无论是获取写锁还是获取读锁都只能等待该线程释放写锁，而一个线程加上读锁，那其他的线程获取写锁需要等待，但是多个线程同时获取读锁；  
简单来说就是：写的时候其他线程不能写不能读，而读的时候其他线程可以读但不能写

## 第十二集：BlockingQueue ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
            /* // 1、抛出异常(插入add(e)、移除remove()、检查element()) // 往阻塞队列中放入元素 System.out.println(blockingQueue.add("a")); // true System.out.println(blockingQueue.add("b")); // true System.out.println(blockingQueue.add("c")); // true System.out.println(blockingQueue.add("d")); // Exception in thread "main" java.lang.IllegalStateException: Queue full // 查看阻塞队列尾部中的元素 System.out.println(blockingQueue.element()); // a // 从阻塞队列中取出元素 System.out.println(blockingQueue.remove()); // a System.out.println(blockingQueue.remove()); // b System.out.println(blockingQueue.remove()); // c System.out.println(blockingQueue.remove()); // Exception in thread "main" java.util.NoSuchElementException */
    
            /* // 2、返回布尔值(插入offer(e)、移除poll()、检查peek()) // 往阻塞队列中放入元素 System.out.println(blockingQueue.offer("a")); // true System.out.println(blockingQueue.offer("b")); // true System.out.println(blockingQueue.offer("c")); // true System.out.println(blockingQueue.offer("d")); // false // 查看阻塞队列尾部中的元素 System.out.println(blockingQueue.peek()); // a // 从阻塞队列中取出元素 System.out.println(blockingQueue.poll()); // a System.out.println(blockingQueue.poll()); // b System.out.println(blockingQueue.poll()); // c System.out.println(blockingQueue.poll()); // null */
    
            /* // 3、阻塞(插入put(e)、移除take()) // 往阻塞队列中放入元素 blockingQueue.put("a"); // 不阻塞 blockingQueue.put("b"); // 不阻塞 blockingQueue.put("c"); // 不阻塞 blockingQueue.put("d"); // 阻塞 // 从阻塞队列中取出元素 System.out.println(blockingQueue.take()); // a System.out.println(blockingQueue.take()); // b System.out.println(blockingQueue.take()); // c System.out.println(blockingQueue.take()); // 阻塞 */
    
            /* // 4、超时(插入offer(e,time,unit)、移除poll(time,unit)) // 往阻塞队列中放入元素 System.out.println(blockingQueue.offer("a",1,TimeUnit.SECONDS)); // true System.out.println(blockingQueue.offer("b",1,TimeUnit.SECONDS)); // true System.out.println(blockingQueue.offer("c",1,TimeUnit.SECONDS)); // true System.out.println(blockingQueue.offer("d",1,TimeUnit.SECONDS)); // 等待1秒钟之后返回false // 从阻塞队列中取出元素 System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS)); // a System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS)); // b System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS)); // c System.out.println(blockingQueue.poll(1,TimeUnit.SECONDS)); // 等待1秒钟之后返回null */
        }
    }

**解释：**

以上方法如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 8]

阻塞队列有7个实现类，比较重要的实现类有：`ArrayBlockingQueue：由数组结构组成的有界阻塞队列`、`LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列`、`PriorityBlockingQueue：支持优先级排序的无界阻塞队列`，其他几个实现类如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 9]

## 第十三集：线程池的三大方法 ##

**1、newFixedThreadPool(n)代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            try { 
                for (int i = 1; i <= 5; i++) { 
                    int finalI = i;
                    threadPool.submit(() -> { 
                        System.out.println(Thread.currentThread().getName() + "办理" + finalI + "号业务");
                    });
                }
            } finally { 
                threadPool.shutdown();
            }
        }
    }

**newFixedThreadPool(n)结果：**

pool-1-thread-1办理1号业务
    pool-1-thread-2办理2号业务
    pool-1-thread-1办理4号业务
    pool-1-thread-2办理5号业务
    pool-1-thread-3办理3号业务

**newFixedThreadPool(n)解释：**

相当于三个员工办理5个业务，无论刮风下雨，3个员工始终在岗，底层代码：

![在这里插入图片描述][20210108190551825.png]  
另外Executor可以用来创建线程池，而ExecutorService是该接口的子接口，相比来说，子接口功能更加强大，因此我们使用子接口ExecutorService，另外submit()方法是可以有返回值的，而execute()方法没有返回值，不过他们都可以提交任务

**2、newSingleThreadExecutor()代码：**

使用

ExecutorService threadPool = Executors.newSingleThreadExecutor();

代替：

ExecutorService threadPool = Executors.newFixedThreadPool(3);

其他的代码和newFixedThreadPool(n)中的代码一致

**newSingleThreadExecutor()结果：**

pool-1-thread-1办理1号业务
    pool-1-thread-1办理2号业务
    pool-1-thread-1办理3号业务
    pool-1-thread-1办理4号业务
    pool-1-thread-1办理5号业务

**newSingleThreadExecutor()解释：**

相当于银行始终只有一个员工，底层代码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 10]

**3、newCachedThreadPool()代码：**

使用

ExecutorService threadPool = Executors.newCachedThreadPool();

代替：

ExecutorService threadPool = Executors.newFixedThreadPool(3);

其他的代码和newFixedThreadPool(n)中的代码一致

**newCachedThreadPool()结果：**

pool-1-thread-2办理2号业务
    pool-1-thread-3办理3号业务
    pool-1-thread-4办理4号业务
    pool-1-thread-1办理1号业务
    pool-1-thread-5办理5号业务

**newCachedThreadPool()解释：**

银行的有`Integer.MAX_VALUE`个员工(Integer.MAX\_VALUE即2147483647)，但是没有默认在岗员工，只要有顾客需要，那这些员工都可以到岗，如果不需要这么多，他们自然不会到岗，底层代码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 11]

## 第十四集：ThreadPoolExecutor的底层原理 ##

对于以上线程池的三大方法，在工作中我们一个也不用，他们都是具有缺陷的，在上面我也给大家展示了它的底层，他们都是new ThreadPoolExecutor()，其中ThreadPoolExecutor实现了AbstractExecutorService，而AbstractExecutorService是ExecutorService接口的子接口，因此我们可以来新建ThreadPoolExecutor对象，我们暂且不说我们此时看到的ThreadPoolExecutor类的构造方法中的5个参数，因为该类还有一个构造方法里面有7个参数，当使用线程池的时候，我们使用的是这7个参数的，我们首先看一下它长什么样子，然后在说明里面参数的含义：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 12]

现在来解释这7个参数的含义：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 13]  
现在来更细致的解释这几个参数：

corePoolSize(核心线程数)：假设该值是3的话，说明线程池中至少有3个线程始终保持活跃，相当于银行窗口的默认值守员工，无论银行有没有顾客，窗口最少有三个员工在值守

maximumPoolSize(最大线程数)：假设该值是10的话，说明线程池中最多有10个线程同时保持活跃，相当于银行最多有10个窗口

keepAliveTime、unit(存活时间)：假设keepAliveTime是2，unit是TimeUnit.HOURS，说明在2个小时之内还用不到大于corePoolSize数量的这些线程的话，那就会销毁这些多余的线程，相当于银行在2个小时之内都只用不到默认的3个窗口办公就行，那只留下3个员工值守就行，其他的员工可以回家休息了

workQueue(阻塞队列)：如果核心线程池中的线程都被用了，那多余的任务f就需要先到阻塞队列中等待，相当于银行的窗口都被顾客用着，那在来的顾客只能去候客厅等着了

threadFactory(创建线程工厂)：创建线程的工厂，毕竟核心线程数不够用了，那还需要创建线程，这就使用到了创建线程的工厂，相当于大堂经理一看人太多了需要增加窗口员工

handler(拒绝策略)：如果任务太多时候的处理办法，一共有4种处理办法，当核心线程数中的线程都被用了，那其他任务先到阻塞队列中，然后创建线程的工厂创建新的线程，一直到达了最大线程数，但是人还是很多，最后阻塞队列也满了，这个时候就需要使用到拒绝策略来处理多余的那些任务

现在来使用通俗易懂的例子来解释这7个参数是怎么回事，假设银行每天默认有3个窗口在开放，无论有没有顾客都有这三个窗口都必须开放，这3个窗口就相当于corePoolSize；假设顾客超过了3个，那就需要先去候客厅排号等待，候客厅相当于workQueue；当候客厅已经满了，大堂经理一看这可不行，得赶快加窗口，然后他打电话让几个员工来加班，打开窗口就相当于threadFactory；然后顾客一点点的少了下来，只用3个窗口就够用了，又等了两个小时，还不需要那么多窗口，然后大堂经理就告诉加班的员工可以回去了，这2个小时就相当于keepAliveTime、unit；然后等了一会来了很多顾客，大堂经理一看这得把全部窗口打开，让员工都加班，这10个窗口相当于maximumPoolSize；这个时候候客厅人数得到了缓解，但随着时间的推移，人越来越多，窗口全部打开并且占满着，候客厅也完全满了，外边还有顾客等着进来，大堂经理一看这可不行，不能让顾客等那么久，然后他就去门口告诉那些还要进来的顾客们人已经满了，对他们进行拒绝，这就是handler；

接下来我将说一下maximumPoolSize怎么设置，老师说了需要考虑当前的程序是CPU密集型还是IO密集型，如果是CPU密集型，就需要改成当前电脑或者服务器核数+1或者+2，总结如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 14]

如果是IO密集型处理起来就比较麻烦，因为IO密集型任务线程并不是一直执行任务，所以应该配置尽可能多的线程，比如CPU核数\*2，以上IO密集型配置方法是一个笼统的说法，我们还可以采用某大厂用过的方式，总结如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 15]

然后我说一下如何使用代码来获取当前电脑或者服务器的CPU核数：

int coreNum = Runtime.getRuntime().availableProcessors();

等会我编写代码演示这7个参数使用的时候会具体用到这个方法，不用着急

然后来说一下handler(拒绝策略)，直接看图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 16]  
接下来举出一个例子说明具体如何使用：

public class Test { 
        public static void main(String[] args) throws Exception { 
            ExecutorService threadPool = new ThreadPoolExecutor(
            		3,
                    Runtime.getRuntime().availableProcessors() + 1,
                    2,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<>(100),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
            try { 
                for (int i = 1; i <= 100; i++) { 
                    int finalI = i;
                    threadPool.submit(() -> { 
                        System.out.println(Thread.currentThread().getName() + "办理" + finalI + "号业务");
                    });
                }
            } finally { 
                threadPool.shutdown();
            }
        }
    }

其中 `new LinkedBlockingDeque<>(100)`是Executors中默认使用的，不过我设置了阻塞队列的大小而已，在`第十三集：线程池的三大方法`中写的我也截图了，现在我再来截个图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 17]  
Executors.defaultThreadFactory()、new ThreadPoolExecutor.AbortPolicy()来自于ThreadPoolExecutor.java中的构造方法中：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 18]

如果你想知道该线程池可以同时处理多少任务，你可以使用`（maximumPoolSize+workQueue的大小）之和`计算出来，如果同时处理的并发数大于该值，当使用new ThreadPoolExecutor.AbortPolicy()拒绝策略的时候就会出现`java.util.concurrent.RejectedExecutionException`，所以需要合理设计阻塞队列的大小，最大线程数量是可以计算出来的，那就相等于固定数值，主要根据并发数算出来阻塞队列的大小

## 第十五集：四大函数式接口 ##

**总览：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 19]

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            // Consumer：有输入没有返回值，泛型就是输入值的类型
            Consumer<String> consumer = t -> System.out.println(t);
            consumer.accept("hello world!");
            // Supplier：没有输入没有返回值，泛型就是返回值的类型
            Supplier<String> supplier = ()->{ return "hello world!";};
            System.out.println(supplier.get());
            // Function：有输入有返回值，第一个泛型就是输入值的类型，第二个参数是返回值的类型
            Function<String,Integer> function = t->{ return t.length();};
            System.out.println(function.apply("hello world!"));
            // Predicate：有输入有返回值，泛型就是输入值的类型，返回值是布尔类型
            Predicate<String> predicate = t->{ return t.length()>0;};
            System.out.println(predicate.test("hello world!"));
        }
    }

**结果：**

hello world!
    hello world!
    12
    true

**总结：**

这四个函数式接口在流式计算中很常用

## 第十六集：流式编程 ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            User u1 = new User(11, "a", 23);
            User u2 = new User(12, "b", 24);
            User u3 = new User(13, "c", 22);
            User u4 = new User(14, "d", 28);
            User u5 = new User(16, "e", 26);
            List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
            list.stream().filter(u -> u.getId() % 2 == 0 && u.getAge() > 24)
                    .map(u -> u.getUserName().toUpperCase())
                    .sorted((name1, name2) -> name2.compareTo(name1))
                    .limit(1)
                    .forEach(System.out::println);
        }
    
        @Data
        @AllArgsConstructor
        public static class User { 
            private Integer id;
            private String userName;
            private Integer age;
        }
    }

**结果：**

**解释：**

*  流式计算为数组和集合服务，不为Map服务，对于集合来说，所有集合的父类Collection中有一个stream()方法，所以所有的集合对象都可以用stream方法，而数组可以通过`Arrays.stream(数组名称)`来把一个数组变成流，然后就可以进行流式计算；
 *  stream方法的返回值是一个流，流后面的泛型可以是集合中的数据类型，例如`List<User`>中的`User`，根据`default Stream<E> stream(){XXX}`可知；也可以是数组中的类型，例如`Integer[]`中的`Integer`，根据`public static <T> Stream<T> stream(T[] array){XXX}`可知；
 *  filter中用的是`断定型接口Predicate`，可以用来过滤，传入一个参数，但是返回一个布尔值，最终filter方法返回的是由`Predicate断定型接口的输入值作为泛型的流`，根据`Stream<T> filter(Predicate<? super T> predicate)`可知；
 *  map中用的是`函数型接口Function`，可以用来映射，注意map()可不是集合，传入一个参数，可以返回一个任意类型的参数，最终map方法的返回值是一个由`Function函数型接口的返回值作为泛型的流`，根据`<R> Stream<R> map(Function<? super T, ? extends R> mapper)`可知；
 *  sorted中用的是`比较型接口Comparator`，可以用来比较，需要传输两个相同类型的参数，通过比较得出返回值，例如`o1.compareTo(o2)`就是按照正序排列，而`o2.compareTo(o1)`就是按照倒序排列，返回值就是`比较型接口输入值的类型作为泛型的流`，根据`Stream<T> sorted(Comparator<? super T> comparator)`可知
 *  limit中用的是一个long型的数字，返回的还是调用limit()方法的流类型
 *  forEach中用的是`消费型接口Consumer`，可以用来输出，没有返回值，只需要传输一个参数就可以了，根据`void forEach(Consumer<? super T> action)`可知
 *  collect(Collectors.toList())叫做收集，一般用在最后将流变成一个List集合
 *  toArray()也叫做收集，一般用在最后将流变成一个数组，但是只能是Object类型的
 *  除此之外还有`count()` 、`distinct()` 、`empty()` 、`generate(Supplier<T> s)` 、`mapToInt(ToIntFunction<? super T> mapper)`，但是有可能使用的不是我们平常使用的方法，例如：  
    ![在这里插入图片描述][20210108224318660.png]

## 第十七集：ForkJoin例子 ##

**代码：**

class MyTask extends RecursiveTask<Integer> { 
        private static final Integer ADJUST_VALUE = 10;
        private int begin;
        private int end;
        private int result;
    
        public MyTask(int begin, int end) { 
            this.begin = begin;
            this.end = end;
        }
    
        @Override
        protected Integer compute() { 
            if ((end - begin) <= ADJUST_VALUE) { 
                for (int i = begin; i <= end; i++) { 
                    result = result + i;
                }
            } else { 
                int middle = (begin + end) / 2;
                MyTask task01 = new MyTask(begin, middle);
                MyTask task02 = new MyTask(middle + 1, end);
                task01.fork();
                task02.fork();
                result = task01.join() + task02.join();
            }
            return result;
        }
    }
    
    /** * * 分支合并例子 * * ForkJoinPool * * ForkJoinTask * * RecursiveTask * */
    public class Test { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            MyTask myTask = new MyTask(0, 100);
            ForkJoinPool forkJoinPool = new ForkJoinPool();
            ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
            System.out.println(forkJoinTask.get());
            forkJoinPool.shutdown();
        }
    }

**结果：**

5050

**解释：**

Fork：把一个复杂任务进行分拆，大事化小  
Join：把分拆任务的结果进行合并  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 20]

## 第十八集：CompletableFuture例子 ##

**代码：**

public class Test { 
        // 创建线程池，简单起见就随便创建一个，也不用那7个参数了
        public static final ExecutorService executor = Executors.newFixedThreadPool(3);
    
        public static void main(String[] args) throws Exception { 
            // 注意：使用我们自己创建的线程池去做事情，所以1和3都不用，由于我们没有关闭线程池，所以程序不会停，不要怀疑
    
            // 1、没有返回值的异步回调(Void仅有的一个无参构造方法已经被私有化了，相当于没有返回值)，不使用自己的线程池
            System.out.println("***1、没有返回值的异步回调(Void仅有的一个无参构造方法已经被私有化了)，不使用自己的线程池***");
            CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture1中的代码执行");
            });
    
            // 2、没有返回值的异步回调，使用自己的线程池
            System.out.println("***2、没有返回值的异步回调，使用自己的线程池***");
            CompletableFuture<Void> completableFuture2 = CompletableFuture.runAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture2中的代码执行");
            }, executor);
    
            // 3、用于测试whenComplete()、exceptionally()，然后有返回值的异步回调，不使用自己的线程池
            System.out.println("***3、有返回值的异步回调，不使用自己的线程池***");
            CompletableFuture<Integer> completableFuture3 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture3中的代码执行");
                int i = 10 / 0;
                return 1024;
            });
            System.out.println(completableFuture3.whenComplete((result, exception) -> { 
                System.out.println("whenComplete中的返回值 = " + result);
                System.out.println("whenComplete中的异常 = " + exception);
            }).exceptionally(exception -> { 
                System.out.println("exceptionally中的异常 = " + exception.getMessage());
                // 假设出现异常就返回0
                return 0;
            }).get());
    
            // 4、用于测试whenComplete()、exceptionally()，然后有返回值的异步回调，使用自己的线程池
            System.out.println("***4、有返回值的异步回调，使用自己的线程池***");
            CompletableFuture<Integer> completableFuture4 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture4中的代码执行");
                int i = 10 / 0;
                return 1024;
            }, executor);
    
            // 如果completableFuture4中不出错，只会执行whenComplete()中的内容，而不会执行exceptionally()中的内容；
            // 如果completableFuture4中出错，不仅会执行，whenComplete()中的内容，而且会执行exceptionally()中的内容；
            // 无论是否出错，都会等着completableFuture4中的代码执行完成，才会执行下面的whenComplete()或者exceptionally()方法，
            // 如果completableFuture4中的代码没有执行完成，那会阻塞在这里，等待着代码执行完成
            System.out.println(completableFuture4.whenComplete((result, exception) -> { 
                System.out.println("whenComplete中的返回值 = " + result);
                System.out.println("whenComplete中的异常 = " + exception);
            }).exceptionally(exception -> { 
                System.out.println("exceptionally中的异常 = " + exception.getMessage());
                // 假设出现异常就返回0
                return 0;
            }).get());
    
            // 5、用于测试handle()，相比4的做法，本次直接在handle()中进行返回值处理以及异常处理了，
            // 不需要用到whenComplete和exceptionally两个方法了，直接通过get()方法获取的就是返回值
            System.out.println("***5、有返回值的异步回调，使用自己的线程池，相比4的做法，本次直接在handle()中进行返回值处理以及异常处理***");
            CompletableFuture<Integer> completableFuture5 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture5中的代码执行");
                int i = 10 / 0;
                return 1024;
            }, executor).handle((result, exception) -> { 
                if (exception == null) { 
                    return result;
                }
                return 0;
            });
            System.out.println(completableFuture5.get());
    
            // 6、用于测试thenRunAsync()，不能接收上一步的返回值，不能返回结果，只有成功才能执行thenRunAsync()
            System.out.println("***6、用于测试thenRunAsync()，不能接收上一步的返回值，不能返回结果***");
            CompletableFuture<Void> completableFuture6 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture6中的代码执行");
                return 1024;
            }, executor).thenRunAsync(() -> { 
                System.out.println("thenRunAsync成功执行了");
            }, executor);
            System.out.println(completableFuture6.get());
    
            // 7、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()
            System.out.println("***7、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()***");
            CompletableFuture<Void> completableFuture7 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture7中的代码执行");
                return 1024;
            }, executor).thenAcceptAsync(result -> { 
                System.out.println("thenAcceptAsync接收到返回值=" + result);
            }, executor);
            System.out.println(completableFuture7.get());
    
            // 8、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()
            System.out.println("***8、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()***");
            CompletableFuture<Integer> completableFuture8 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture8中的代码执行");
                return 1024;
            }, executor).thenApplyAsync(result -> { 
                System.out.println("thenAcceptAsync接收到返回值=" + result);
                return result + 1;
            }, executor);
            System.out.println(completableFuture8.get());
    
            CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》future1执行");
                return 1024;
            });
            CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》future2执行");
                return "hello";
            });
    
            CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> { 
                System.out.println(Thread.currentThread().getName() + "》future3执行");
                return 2021;
            });
            // 9、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenCombineAsync方法可以接收future1和future2的返回值，另外该方法还可以返回一个值
            System.out.println("***9、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenCombineAsync方法可以接收future1和future2的返回值，另外该方法还可以返回一个值***");
            CompletableFuture<String> completableFuture9 = future1.thenCombineAsync(future2, (future1Result, future2Result) -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture9执行");
                return future1Result + "和" + future2Result;
            }, executor);
            System.out.println(completableFuture9.get());
    
            // 10、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenAcceptBothAsync方法可以接收future1和future2的返回值，但是不会返回值
            System.out.println("***10、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenAcceptBothAsync方法可以接收future1和future2的返回值，但是不会返回值***");
            CompletableFuture<Void> completableFuture10 = future1.thenAcceptBothAsync(future2, (future1Result, future2Result) -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture10执行");
            }, executor);
    
            // 11、测试两个组合任务，只有future1和future2完成之后才会执行该任务，runAfterBothAsync方法不接收future1和future2的返回值，并且不会返回值
            System.out.println("***11、测试两个组合任务，只有future1和future2完成之后才会执行该任务，runAfterBothAsync方法不接收future1和future2的返回值，并且不会返回值***");
            CompletableFuture<Void> completableFuture11 = future1.runAfterBothAsync(future2, () -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture11执行");
            }, executor);
    
            // 12、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，applyToEitherAsync方法可以接收future1或者future3的返回值，并且会返回值，另外要求future1和future3返回值类型一致，当然你可以都用Object
            System.out.println("***12、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，applyToEitherAsync方法可以接收future1或者future3的返回值，并且会返回值，另外要求future1和future3返回值类型一致***");
            CompletableFuture<Integer> completableFuture12 = future1.applyToEitherAsync(future3, futureResult -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture12执行");
                return futureResult;
            }, executor);
            System.out.println(completableFuture12.get());
    
            // 13、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，acceptEitherAsync方法可以接收future1或者future3的返回值，但是不会返回值，另外要求future1和future3返回值类型一致，当然你可以都用Object
            System.out.println("***13、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，acceptEitherAsync方法可以接收future1或者future3的返回值，但是不会返回值，另外要求future1和future3返回值类型一致***");
            CompletableFuture<Void> completableFuture13 = future1.acceptEitherAsync(future3, futureResult -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture13执行");
            }, executor);
    
            // 14、测试两个组合任务，只要future1和future2有一个完成之后就会执行该任务，runAfterEitherAsync方法不会接收future1或者future3的返回值，也不会返回值，不要求future1和future2返回值类型一致
            System.out.println("***14、测试两个组合任务，只要future1和future2有一个完成之后就会执行该任务，runAfterEitherAsync方法不会接收future1或者future3的返回值，也不会返回值，不要求future1和future2返回值类型一致***");
            CompletableFuture<Void> completableFuture14 = future1.runAfterEitherAsync(future2, () -> { 
                System.out.println(Thread.currentThread().getName() + "》completableFuture14执行");
            }, executor);
    
            // 15、测试多个组合任务，只有全部任务完成才算完成
            System.out.println("***15、测试多个组合任务，只有全部任务完成才算完成***");
            CompletableFuture<Void> completableFuture15 = CompletableFuture.allOf(future1, future2, future3);
            completableFuture15.get();
            System.out.println("多组合任务完成，最终future1.get()=" + future1.get() + "、future2.get()=" + future2.get() + "、future3.get()=" + future3.get());
    
            // 16、测试多个组合任务，只要有一个完成就算完成
            System.out.println("***16、测试多个组合任务，只要有一个完成就算完成***");
            CompletableFuture<Object> completableFuture16 = CompletableFuture.anyOf(future1, future2, future3);
            completableFuture16.get();
            System.out.println("多组合任务完成，最终completableFuture16.get()=" + completableFuture16.get());
        }
    }

**结果：**

***1、没有返回值的异步回调(Void仅有的一个无参构造方法已经被私有化了)，不使用自己的线程池***
    ***2、没有返回值的异步回调，使用自己的线程池***
    ForkJoinPool.commonPool-worker-1》completableFuture1中的代码执行
    ***3、有返回值的异步回调，不使用自己的线程池***
    pool-1-thread-1》completableFuture2中的代码执行
    ForkJoinPool.commonPool-worker-1》completableFuture3中的代码执行
    whenComplete中的返回值 = null
    whenComplete中的异常 = java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
    exceptionally中的异常 = java.lang.ArithmeticException: / by zero
    0
    ***4、有返回值的异步回调，使用自己的线程池***
    pool-1-thread-2》completableFuture4中的代码执行
    whenComplete中的返回值 = null
    whenComplete中的异常 = java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
    exceptionally中的异常 = java.lang.ArithmeticException: / by zero
    0
    ***5、有返回值的异步回调，使用自己的线程池，相比4的做法，本次直接在handle()中进行返回值处理以及异常处理***
    pool-1-thread-3》completableFuture5中的代码执行
    0
    ***6、用于测试thenRunAsync()，不能接收上一步的返回值，不能返回结果***
    pool-1-thread-1》completableFuture6中的代码执行
    thenRunAsync成功执行了
    null
    ***7、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()***
    pool-1-thread-3》completableFuture7中的代码执行
    thenAcceptAsync接收到返回值=1024
    null
    ***8、用于测试thenAcceptAsync()，可以接收上一步的返回值，不能返回结果，只有成功才能执行thenAcceptAsync()***
    pool-1-thread-2》completableFuture8中的代码执行
    thenAcceptAsync接收到返回值=1024
    1025
    ForkJoinPool.commonPool-worker-1》future1执行
    ForkJoinPool.commonPool-worker-1》future2执行
    ***9、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenCombineAsync方法可以接收future1和future2的返回值，另外该方法还可以返回一个值***
    ForkJoinPool.commonPool-worker-1》future3执行
    pool-1-thread-1》completableFuture9执行
    1024和hello
    ***10、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenAcceptBothAsync方法可以接收future1和future2的返回值，但是不会返回值***
    ***11、测试两个组合任务，只有future1和future2完成之后才会执行该任务，thenCombineAsync方法可以接收future1和future2的返回值，但是不会返回值***
    pool-1-thread-2》completableFuture10执行
    ***12、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，thenCombineAsync方法可以接收future1或者future3的返回值，但是会返回值，另外要求future1和future3返回值类型一致***
    pool-1-thread-3》completableFuture11执行
    pool-1-thread-1》completableFuture12执行
    1024
    ***13、测试两个组合任务，只要future1和future3有一个完成之后就会执行该任务，acceptEitherAsync方法可以接收future1或者future3的返回值，但是不会返回值，另外要求future1和future3返回值类型一致***
    ***14、测试两个组合任务，只要future1和future2有一个完成之后就会执行该任务，runAfterEitherAsync方法不会接收future1或者future3的返回值，也不会返回值，不要求future1和future2返回值类型一致***
    pool-1-thread-2》completableFuture13执行
    ***15、测试多个组合任务，只有全部任务完成才算完成***
    pool-1-thread-3》completableFuture14执行
    多组合任务完成，最终future1.get()=1024、future2.get()=hello、future3.get()=2021
    ***16、测试多个组合任务，只要有一个完成就算完成***
    多组合任务完成，最终completableFuture16.get()=1024

**解释：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 21]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 24]  
![在这里插入图片描述][20210111112802595.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 25]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 26]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 27]

## 第十九集：Volatile关键字 ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            Demo demo = new Demo();
            new Thread(demo).start();
            while (true) { 
                if (demo.isFlag()) { 
                    System.out.println("______________");
                    break;
                }
            }
        }
    }
    
    class Demo implements Runnable { 
        private boolean flag = false;
    
        @Override
        public void run() { 
            try { 
                Thread.sleep(200);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            flag = true;
            System.out.println("flag=" + isFlag());
        }
    
        public boolean isFlag() { 
            return this.flag;
        }
    
        public void setFlag(boolean flag) { 
            this.flag = flag;
        }
    }

**结果：**

出现`flag=true`之后线程就阻塞了

**解释：**

可以看到有主线程和分支线程一共两个线程，其实flag存在于主存中，然后分支线程运行的时候会把flag读入到当前线程的缓存中，之后主线程也会把flag读入当前线程的的缓存中，当然他们读到的都是false，然后分支线程把flag改成了true，由于while是一个很快的操作，所以此时主线程不知道flag已经发生改变了，那么通过demo.isFlag()获取的一直就是false，因此线程不会结束，例如：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 28]  
如果想解决这个问题，我们需要把

private boolean flag = false;

变成

private volatile boolean flag = false;

这样对flag的所有操作都只在主存中进行了，其他的操作该在缓存中还在缓存中进行，因此上面的那幅图就可以这样画：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 29]  
**总结：**

1.  可以保证内存中的数据可见性，也就是在多个线程操作共享数据的时候，相当于这些操作都在主存中进行，和各个线程的缓存没有关系
2.  volatile不具备互斥性质，也就是说被对该数据的操作虽然在主存中进行，但是依然是多个线程同时可以对该数据进行读写，当然这也可以说成是原子性
3.  volatile可以禁止指令重排，指令重排就是对象创建的的时候有几个步骤，这几个步骤要按照顺序来，不能反了，由于要提高效率，所以默认是反的，而volatile的作用就是不让反

## 第二十集：原子类 ##

**代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            Demo demo = new Demo();
            for (int i = 0; i < 10; i++) { 
                new Thread(demo).start();
            }
        }
    }
    
    class Demo implements Runnable { 
        private int serialNumber = 0;
    
        @Override
        public void run() { 
            // 避免出不来原子性
            try { 
                Thread.sleep(200);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            // 打印出数字
            System.out.println(getSerialNumber());
        }
        // 执行加1操作
        public int getSerialNumber() { 
            return this.serialNumber++;
        }
    }

**结果：**

多个相同数字出现，说明修改的时候发生了冲突

**改编代码：**

public class Test { 
        public static void main(String[] args) throws Exception { 
            Demo demo = new Demo();
            for (int i = 0; i < 10; i++) { 
                new Thread(demo).start();
            }
        }
    }
    
    class Demo implements Runnable { 
        // AtomicInteger是原子类，里面有volatile关键字，可以保证内存中的数据可见性
        private AtomicInteger serialNumber = new AtomicInteger();
    
        @Override
        public void run() { 
            // 避免出不来原子性
            try { 
                Thread.sleep(200);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            // 打印出数字
            System.out.println(getSerialNumber());
        }
    
        // 执行加1操作
        private int getSerialNumber() { 
            return this.serialNumber.getAndIncrement();
        }
    }

**结果：**

所有数字都是不相同的

**解释：**

本次使用的AtomicInteger是java.util.concurrent.atomic中的类，这里面的类可以保证数据可见性和原子性操作，具体解释如下：

1.  使用volatile关键字保证了数据的可见性，相当于对于数据的操作都在主存中进行，不涉及到单个线程中缓存的事情
2.  JVM在里面使用了CAS算法（Compare-And-Swap），其中CAS算法可以保证数据的原子性，它是硬件对于并发操作共享数据的支持，CAS中包含了三个操作数，分别是内存值V（比较之前从主存中取出来的value值）、预估值A（比较之时从主存中取出来的value值）、更新值B（即我们想设置的值，如果通过比较发现内存值V和预估值A相等，就会将主存中的value值改成更新值B），解释这三个值之后我说一下如何进行数据更新，当且仅当内存值V==预估值A时，才将内存中的value值即内存值V设置成更新值B，否则更新失败，然后就执行循环操作，也就是继续进行更新操作，直到更新成功，这种做法比使用synchronized锁的效率更高，因为如果更新失败的话，该线程会立即继续进行尝试更新操作，这样不会浪费CPU的时间片（执行权），所以效率更高，至于CAS图解如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 30]

[20210107150017823.png]: /images/20221119/33c66104e42b41c2b9d81e143bccf5c2.png
[JVM]: https://blog.csdn.net/qq_42449963/article/details/109379124
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70]: /images/20221119/c81680cf631e4c4581b7dff866f96b5f.png
[Lambda]: https://blog.csdn.net/qq_42449963/article/details/109258287
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 1]: /images/20221119/c67ddc3d8aa24051b900a0cc8d715e0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 2]: /images/20221119/a09e818cc5284cc8a4a667067878a371.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 3]: /images/20221119/cff9f5d876b34cea91de82c501a6fa85.png
[20210222124022816.png]: /images/20221119/6f8cf8a3fd2e4ab1bd7361a5a000eb4a.png
[20210107213545576.png]: /images/20221119/337f5b4b72d9440a8ca8f3d4402be910.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 4]: /images/20221119/917e8cb59a8245e7abf033ad1dd91477.png
[20210107212716869.png]: /images/20221119/12f111fe2d5c40209b10a6a9ba6de82e.png
[20210107212800119.png]: /images/20221119/7f0bba2d31d44306b15ce2a810721cad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 5]: /images/20221119/3c420f242c0e4b9ebb8652750263b2c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 6]: /images/20221119/bcf20138e9fb41f493bf504c7d381232.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 7]: /images/20221119/ae8c2f9d9b2049de856c616cc1bf0d78.png
[2021010722172765.png]: /images/20221119/68df1ce5a3fd4557899e771e98ef923f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 8]: /images/20221119/82dc1e0fe7344795b211cb1129277641.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 9]: /images/20221119/ae34b219833748b9bbaedfe599f13a8f.png
[20210108190551825.png]: /images/20221119/e41de3bbd930478da9c8d3957abce452.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 10]: /images/20221119/786628733cbf4d1ab733308d7abe1aee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 11]: /images/20221119/7a95b52323b04304b2ad4f06255b447f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 12]: /images/20221119/d934ca6ec4a542129ce0a4732b93e815.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 13]: /images/20221119/f229242afd5642f0b3a814aedd1e09d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 14]: /images/20221119/0f61e1a746564bc4a052d37725603f66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 15]: /images/20221119/72c105f2139745738de7b90093302407.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 16]: /images/20221119/0275cf88187049d09ac0f963d6ed7709.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 17]: /images/20221119/f5f2e47b97fa46eb8c67e5790e30cd99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 18]: /images/20221119/f9d7be5a65c74974bd367b287db73cf1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 19]: /images/20221119/e3cd75c01a444f2cb2a56b3da761b5d0.png
[20210108224318660.png]: /images/20221119/7d181006bd2448b9ac0f05a06ab000dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 20]: /images/20221119/b123d136aaa741b1a7dea783bab91b06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 21]: /images/20221119/8dd24f57029e41f8a135cd99a2524f98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 22]: /images/20221119/839be4c067514fa7afab8e79968eb9a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 23]: /images/20221119/ff56008213124b6fb691f44f5f4d1814.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 24]: /images/20221119/0c4fc8d6a06e4c13a4c5b5b405ec5892.png
[20210111112802595.png]: /images/20221119/06f77386d90d4a79ab007830b241e6ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 25]: /images/20221119/94892a1abf3c4d4e97b874f5c367a728.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 26]: /images/20221119/d85d821b6b4c4a809aea1ec23ef1c582.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 27]: /images/20221119/1b6ab63399a24dca992770d418d43dba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 28]: /images/20221119/ad1cee45f12645d79aedbe64e86f3614.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 29]: /images/20221119/fd6a7af12ec94428adabdc4e65128791.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDQ5OTYz_size_16_color_FFFFFF_t_70 30]: /images/20221119/1b5f1c5149f348378df3c5a8cacbbd8e.png