编程语言
首页 > 编程语言> > JUC 并发编程

JUC 并发编程

作者:互联网

JUC

1、什么是JUC

JUC:Java util 工具包、包、分类

源码 + 官方文档 面试高频问!

业务:普通的线程代码 Thread

Runnable 没有返回值、效率相比入 Callable 相对较低!

 

2、进程和线程

线程、进程,如果不能使用一句话说出来的技术,不扎实!

进程:一个程序,QQ.exe Music.exe 程序的集合; 一个进程往往可以包含多个线程,至少包含一个! Java默认有几个线程? 2 个 mian、GC 线程:开了一个进程 Typora,写字,自动保存(线程负责的) 对于Java而言:Thread、Runnable、Callable

Java 真的可以开启线程吗? 开不了

     public synchronized void start() {
         /**
          * This method is not invoked for the main method thread or "system"
          * group threads created/set up by the VM. Any new functionality added
          * to this method in the future may have to also be added to the VM.
          *
          * A zero status value corresponds to state "NEW".
          */
         if (threadStatus != 0)
             throw new IllegalThreadStateException();
 ​
         /* Notify the group that this thread is about to be started
          * so that it can be added to the group's list of threads
          * and the group's unstarted count can be decremented. */
         group.add(this);
 ​
         boolean started = false;
         try {
             start0();
             started = true;
         } finally {
             try {
                 if (!started) {
                     group.threadStartFailed(this);
                 }
             } catch (Throwable ignore) {
                 /* do nothing. If start0 threw a Throwable then
                   it will be passed up the call stack */
             }
         }
     }
 ​
     // 本地方法,底层的C++ Java无法直接操作硬件!
     private native void start0();

并发、并行

并发编程:并发、并行

并发(多线程操作同一个资源)

CPU 一核 ,模拟出来多条线程,天下武功,唯快不破,快速交替 并行(多个人一起行走)

CPU 多核 ,多个线程可以同时执行; 线程池

 public class Test {
     public static void main(String[] args) {
         // 获取CPU核数
         // CPU密集型、IO密集型
         System.out.println(Runtime.getRuntime().availableProcessors());
     }
 }

并发编程的本质:充分利用CPU的资源

所有公司都很看重!

企业,挣钱=> 提高效率,裁员,找一个厉害的人顶替三个不怎么样的人!

人员(减) 、技术成本(高)

线程有几个状态

 public enum State {
 ​
     // 新生
     NEW,
 ​
     // 运行
     RUNNABLE,
 ​
     // 阻塞
     BLOCKED,
 ​
     // 等待,死死地等!
     WAITING,
 ​
     // 超时等待
     TIMED_WAITING,
 ​
     //终止~
     TERMINATED;
 }

wait / sleep 区别

1、来自不同的类

wait - - > Object

sleep - - > Thread

2、关于锁的释放

wait 会释放锁,sleep 睡觉了,抱着锁睡觉,不会释放!

3、使用的返回是不同的

wait

必须是在同步代码块中

sleep可以在任何地方睡觉

4、是否需要捕获异常

wait 不需要捕获异常

sleep 必须要捕获异常

 

3、Lock锁(重点)

传统Synchronized

 package com.jack.Demo;
 ​
 /**
  * 真正的多线程开发,公司中的开发!降低耦合性~
  * 线程就是一个单独的资源类,没有任何负数操作!
  * 1、属性 、 方法
  */
 public class SaleTicketDemo01 {
 ​
     public static void main(String[] args) {
         // 并发:多线程操作同一个资源,把资源丢入线程
         Ticket ticket = new Ticket();
 ​
         // @FunctionalInterface 函数式接口,jdk1.8 lambda表达式(参数)->{ 代码 }
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"B").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"C").start();
     }
 }
 ​
 // 资源类 OOP
 class Ticket{
     // 属性、方法
     private int number = 50;
 ​
     //卖票的方式
     public synchronized void sale(){
         if (number>0){
             System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票"+"剩余:"+number);
         }
     }
 }

Lock 接口

公平锁:十分公平:可以先来后到

非公平锁:十分不公平:可以插队 (默认)

 package com.jack.Demo;
 ​
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 ​
 public class SaleTicketDemo02 {
 ​
     public static void main(String[] args) {
         // 并发:多线程操作同一个资源,把资源丢入线程
         Ticket2 ticket = new Ticket2();
 ​
         // @FunctionalInterface 函数式接口,jdk1.8 lambda表达式(参数)->{ 代码 }
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"B").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 40; i++) {
                 ticket.sale();
             }
         },"C").start();
 ​
     }
 }
 // Lock 三部曲
 // 1、new ReentrantLock();
 // 2、lock.lock(); 加锁
 // 3、finally => Lock.unlock(); 解锁
 class Ticket2 {
     // 属性、方法
     private int number = 50;
 ​
     Lock lock = new ReentrantLock();
 ​
     //卖票的方式
     public void sale() {
 ​
         lock.lock(); // 加锁
 ​
         try {
             // 业务代码
             if (number > 0) {
                 System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票" + "剩余:" + number);
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock(); // 解锁
         }
 ​
     }
 }

Synchronized 和 Lock 区别

1、Synchronized 内置的Java关键字,Lock是一个Java类!

2、Synchronized 无法判断获取锁的状态,Lock 可以判断是否获取到了锁!

3、Synchronized 会自动释放锁,Lock必须手动释放锁!如果不释放锁,死锁!

4、Synchronized 线程1(获得锁,阻塞)、线程2(等待,傻傻的等);Lock锁就不一定会等待下去!

5、Synchronized 可重入锁,不可以中断,非公平;Lock,可重入锁,可以判断锁。非公平(可以自己设置)!

6、Synchronized 适合锁少量的代码同步问题,Lock 适合锁大量的同步代码!

 

锁是什么,如何判断锁的是谁!

 

 

4、生产者和消费者问题

面试的:单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 Synchronized 版

 /**
 * 线程之间的通信问题:生产者和消费者问题! 等待唤醒,通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 */
 public class A {
 ​
     public static void main(String[] args) {
         Data data = new Data();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"B").start();
     }
 }
 ​
 // 判断等待、业务、通知
 class Data{ // 数字 资源类
 ​
     private int number = 0;
 ​
     // +1
     public synchronized void increment() throws InterruptedException {
         if (number != 0){
             // 等待
             this.wait();
         }
         number++;
         System.out.println(Thread.currentThread().getName()+"=>"+number);
         // 通知其他线程,我+1完毕了
         this.notifyAll();
     }
 ​
     // -1
     public synchronized void decrement() throws InterruptedException {
         if (number == 0){
             // 等待
             this.wait();
         }
         number--;
         System.out.println(Thread.currentThread().getName()+"=>"+number);
         // 通知其他线程,我-1完毕了
         this.notifyAll();
     }
 }

问题存在 ,A、B、C、D 四个线程!虚假唤醒!

解决方法: if 改为 while 判断

 /**
 * 线程之间的通信问题:生产者和消费者问题! 等待唤醒,通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 */
 public class A {
 ​
     public static void main(String[] args) {
         Data data = new Data();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"B").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"C").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"D").start();
     }
 }
 ​
 // 判断等待、业务、通知
 class Data{ // 数字 资源类
 ​
     private int number = 0;
 ​
     // +1
     public synchronized void increment() throws InterruptedException {
         while (number != 0){
             // 等待
             this.wait();
         }
         number++;
         System.out.println(Thread.currentThread().getName()+"=>"+number);
         // 通知其他线程,我+1完毕了
         this.notifyAll();
     }
 ​
     // -1
     public synchronized void decrement() throws InterruptedException {
         while (number == 0){
             // 等待
             this.wait();
         }
         number--;
         System.out.println(Thread.currentThread().getName()+"=>"+number);
         // 通知其他线程,我-1完毕了
         this.notifyAll();
     }
 }

 

JUC 版的生产者和消费者问题

通过Lock 找到 Condition

代码实现:

 /**
  * 线程之间的通信问题:生产者和消费者问题! 等待唤醒,通知唤醒 * 线程交替执行 A B 操作同一个变量 num = 0
  * A num+1
  * B num-1
  */
 public class B {
 ​
     public static void main(String[] args) {
         Data2 data = new Data2();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"B").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.increment();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"C").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 try {
                     data.decrement();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"D").start();
     }
 }
 ​
 // 判断等待、业务、通知
 class Data2{ // 数字 资源类
 ​
     private int number = 0;
     Lock lock = new ReentrantLock();
     Condition condition = lock.newCondition();
 ​
     // condition.await(); // 等待
     // condition.signalAll(); // 唤醒全部
 ​
     // +1
     public void increment() throws InterruptedException {
 ​
         lock.lock();
         try {
             while (number != 0){
                 // 等待
                 condition.await();
             }
             number++;
             System.out.println(Thread.currentThread().getName()+"=>"+number);
             // 通知其他线程,我+1完毕了
             condition.signalAll();
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             lock.unlock();
         }
 ​
     }
 ​
     // -1
     public void decrement() throws InterruptedException {
 ​
         lock.lock();
 ​
         try {
             while (number == 0){
                 // 等待
                 condition.await();
             }
             number--;
             System.out.println(Thread.currentThread().getName()+"=>"+number);
             // 通知其他线程,我-1完毕了
             condition.signalAll();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 }

任何一个新的技术,绝对不是仅仅是技术的覆盖,而是优势、补充!

Condition 精准的通知和唤醒线程

代码实现:

 /**
  *  A 执行完调用 B,B 执行完调用C,C执行完调用A
  */
 public class C {
 ​
     public static void main(String[] args) {
         Data3 data = new Data3();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 data.printA();
             }
         },"A").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 data.printB();
             }
         },"B").start();
 ​
         new Thread(()->{
             for (int i = 0; i < 10; i++) {
                 data.printC();
             }
         },"C").start();
     }
 }
 ​
 ​
 class Data3 { //  资源类
 ​
     private int number = 1; // A:1 、B:2、C:3
     Lock lock = new ReentrantLock();
     Condition condition1 = lock.newCondition();
     Condition condition2 = lock.newCondition();
     Condition condition3 = lock.newCondition();
 ​
     // condition.await(); // 等待
     // condition.signalAll(); // 唤醒全部
 ​
     public void printA() {
 ​
         lock.lock();
 ​
         try {
             //    业务,判断- > 执行 -> 通知
             while (number!=1){
                 // 等待
                 condition1.await();
             }
             System.out.println(Thread.currentThread().getName()+"=>A");
             // 唤醒 指定的人:B
             number = 2;
             condition2.signal();
 ​
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 ​
     public void printB() {
 ​
         lock.lock();
 ​
         try {
             //    业务,判断- > 执行 -> 通知
             while (number!=2){
                 // 等待
                 condition2.await();
             }
             System.out.println(Thread.currentThread().getName()+"=>B");
             // 唤醒 指定的人:C
             number = 3;
             condition3.signal();
 ​
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 ​
     public void printC() {
 ​
         lock.lock();
 ​
         try {
             //    业务,判断- > 执行 -> 通知
             while (number!=3){
                 // 等待
                 condition3.await();
             }
             System.out.println(Thread.currentThread().getName()+"=>C");
             // 唤醒 指定的人:A
             number = 1;
             condition1.signal();
 ​
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 }

 

5、8锁现象

如何判断锁的是谁!永远的知道什么是锁,锁到底是锁谁的锁!

深刻理解我们的锁!

 /**
  * 8锁,就是关于锁的8个问题
  * 1、标准情况下,两个线程先打印 发短信还是 打电话? 1/发短信 2/打电话
  * 1、sendSms延迟4秒,两个线程先打印 发短信还是 打电话? 1/发短信 2/打电话
  * */
 public class Test1 {
     public static void main(String[] args) {
 ​
         Phone phone = new Phone();
 ​
         // 锁的存在 
         new Thread(()->{
             phone.sendSms();
         },"A").start();
 ​
         // 捕获
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         new Thread(()->{
             phone.call();
         },"B").start();
     }
 }
 ​
 class Phone{
 ​
     // synchronized 锁的对象是方法的调用者!
     // 两个方法调用的是同一个锁、谁先拿到谁先执行!
     public synchronized  void sendSms(){
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("发短信");
     }
 ​
     public synchronized  void call(){
         System.out.println("打电话");
     }
 }
 /**
  * 3、增加一个普通方法后!先执行发短信还是 hello ? 普通方法
  * 4、两个对象、两个同步方法, 发短信还是 打电话  | 打电话
  */
 public class Test2 {
     public static void main(String[] args) {
 ​
         // 两个对象、两个调用者、两把锁!
         Phone2 phone1 = new Phone2();
         Phone2 phone2 = new Phone2();
 ​
         // 锁的存在!
         new Thread(()->{
             phone1.sendSms();
         },"A").start();
 ​
         // 捕获
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         new Thread(()->{
             phone2.call();
         },"B").start();
     }
 }
 ​
 class Phone2{
 ​
     // synchronized 锁的对象是方法的调用者!
     // 两个方法调用的是同一个锁、谁先拿到谁先执行!
     public synchronized  void sendSms(){
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("发短信");
     }
 ​
     public synchronized  void call(){
         System.out.println("打电话");
     }
 ​
     // 这里没有锁!不是同步方法,不收锁的影响!
     public void hello(){
         System.out.println("hello");
     }
 }
 /**
  * 5、增加两个静态的同步方法,只有一个对象,先打印 发短信? 打电话?
  * 6、两个对象!增加两个静态的同步方法,只有一个对象,先打印 发短信? 打电话?
  */
 public class Test3 {
     public static void main(String[] args) {
 ​
         // 两个对象的Class类模板只有一个,static,锁的是Class
         Phone3 phone1 = new Phone3();
         Phone3 phone2 = new Phone3();
 ​
         // 锁的存在!
         new Thread(()->{
             phone1.sendSms();
         },"A").start();
 ​
         // 捕获
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         new Thread(()->{
             phone2.call();
         },"B").start();
     }
 }
 ​
 // Phone3唯一的一个 Class 对象
 class Phone3{
 ​
     // synchronized 锁的对象是方法的调用者!
     // static 静态方法
     // 类一加载就有了!锁的是Class
     public static synchronized void sendSms(){
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("发短信");
     }
 ​
     public static synchronized void call(){
         System.out.println("打电话");
     }
 ​
 }
 /**
  * 1、 1个静态的同步方法,1个普通的方法,一个对象,先打印 发短信?  |  打电话?
  * 2、 1个静态的同步方法,1个普通的方法,两个对象,先打印 发短信?  |  打电话?
  */
 public class Test4 {
     public static void main(String[] args) {
 ​
         // 两个对象的Class类模板只有一个,static,锁的是Class
         Phone4 phone1 = new Phone4();
         Phone4 phone2 = new Phone4();
 ​
         // 锁的存在!
         new Thread(()->{
             phone1.sendSms();
         },"A").start();
 ​
         // 捕获
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         new Thread(()->{
             phone2.call();
         },"B").start();
     }
 }
 ​
 // Phone3唯一的一个 Class 对象
 class Phone4{
 ​
     // 静态的同步方法 锁的是 Class 类模板
     public static synchronized void sendSms(){
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("发短信");
     }
 ​
     // 普通的同步方法 锁的是调用者
     public  synchronized void call(){
         System.out.println("打电话");
     }
 ​
 }

小结

new this 具体的一个手机

static Class 唯一的一个模板

如果在静态代码块里面加类锁,那就不一样了,实例方法也要在静态代码块的类锁释放之后才能执行

 

6、集合类不安全

List不安全

 import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 ​
 // java.util.ConcurrentModificationException
 public class ListTest {
     public static void main(String[] args) {
         // 并发下 ArrayList 不安全的吗 ,Synchronized
         /**
          * 解决方案:
          * 1、List<String> list = new Vector<>();
          * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
          * 3、List<String> list = new CopyOnWriteArrayList<>();
          */
         // CopyOnWrite 写入时复制  COW 计算机程序设计领域的一种策略优化
         // 多个线程调用的时候, list ,读取得时候,固定的,写入(覆盖)
         // 在写入的时候避免覆盖,造成数据问题!
         // 读写分离
         // CopyOnWriteArrayList  比 Veector Bb 在哪里?
 ​
         List<String> list = new CopyOnWriteArrayList<>();
 ​
         for (int i = 0; i < 10; i++) {
             new Thread(()->{
                 list.add(UUID.randomUUID().toString().substring(0,5));
                 System.out.println(list);
             },String.valueOf(i)).start();
         }
     }
 }

小狂神的推荐学习方法:1、先会用,2、货比三家,寻找解决方案,3、分析源码!

Set不安全

 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArraySet;
 ​
 /**
  * 同理可证:java.util.ConcurrentModificationException
  * 1、Set<String> set = Collections.synchronizedSet(new HashSet<>());
  * 2、Set<String> set = new CopyOnWriteArraySet<>();
  */
 public class SetTest {
     public static void main(String[] args) {
 ​
         //Set<String> set = new HashSet<>();
         //Set<String> set = Collections.synchronizedSet(new HashSet<>());
         Set<String> set = new CopyOnWriteArraySet<>();
 ​
         for (int i = 0; i < 30; i++) {
             new Thread(()->{
                 set.add(UUID.randomUUID().toString().substring(0,5));
                 System.out.println(set);
             },String.valueOf(i)).start();
         }
     }
 }

hashSet 底层是什么?

 public HashSet() {
     map = new HashMap<>();
 }
 ​
 // add set 本质就是 map key是无法重复的!
 public boolean add(E e) {
     return map.put(e, PRESENT)==null;
 }
 ​
 private static final Object PRESENT = new Object(); // 不变的值!

Map不安全

回顾Map基本操作

 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 ​
 // java.util.ConcurrentModificationException
 public class MapTest {
     public static void main(String[] args) {
         /**
          *  map 是这样用的嘛? 不是,工作中不用 HashMap
          *  默认等价于什么? new HshMap<></>(16,0.75);
          *  Map<String, String> map = new HashMap<>();
          *  唯一的一个探究: ConcurrentHashmap 原理!
          */
 ​
         Map<String, String> map = new ConcurrentHashMap<>();
 ​
         for (int i = 0; i < 30; i++) {
             new Thread(()->{
                 map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                 System.out.println(map);
             },String.valueOf(i)).start();
         }
     }
 }

 

7、Callbale(简单)

1、可以有返回值

2、可以抛出异常

3、方法不听 run() / call()

代码实现

 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 ​
 /**
  * 1、探究原理
  * 2、觉得自己会用就可以 !
  */
 public class CallableTest {
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         //new Thread(new Runnable() ).start();
         //new Thread(new FutureTask<V>() ).start();
         //new Thread(new FutureTask<V>( Callable ) ).start();
         new Thread().start();
 ​
         MyThread thread = new MyThread();
         FutureTask futureTask = new FutureTask(thread);
 ​
         new Thread(futureTask,"A").start(); // 适配类
         new Thread(futureTask,"A").start(); // 结果会有缓存,效率高!
 ​
     // 这个 get 方法可能会产生阻塞! 把他放在最后~  或者使用异步通信来处理!
         Object o = (Integer)futureTask.get(); // 获取Callable的返回结果!
         System.out.println(o);
 ​
     }
 }
 ​
 class MyThread implements Callable<Integer>{
     @Override
     public Integer call() throws Exception {
         System.out.println("call()");
         return 1024;
     }
 }

细节:

1、有缓存

2、结果可能需要等待,会阻塞!

 

8、常用的辅助类(必会)

8.1、CountDownLatch

 import java.util.concurrent.CountDownLatch;
 ​
 // 计数器
 public class CountDownLatchDemo {
     public static void main(String[] args) throws InterruptedException {
         // 总数是6,必须要执行任务的时候,在使用!
         CountDownLatch countDownLatch = new CountDownLatch(6);
 ​
         for (int i = 1; i <= 6; i++) {
             new Thread(() -> {
                 System.out.println(Thread.currentThread().getName() + "Go out");
                 countDownLatch.countDown(); // 数量-1
             }, String.valueOf(i)).start();
         }
             countDownLatch.await(); // 等待计数器归零,然后向下执行
 ​
             System.out.println("Close Door");
     }
 }

原理:

 

8.2CyclicBarrier

加法计数器

 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.CyclicBarrier;
 ​
 public class CyclicBarrierDemo {
     public static void main(String[] args) {
         /**
          * 集齐7颗控住召唤神龙
          */
         // 召唤神龙的线程
         CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
             System.out.println("召唤神龙成功!");
         });
         for (int i = 1; i <= 7 ; i++) {
             final int temp = i;
             // lambda 能操作 i 嘛?
             new Thread(()->{
                 System.out.println(Thread.currentThread().getName()+"收集"+temp+"颗龙珠");
                 try {
                     cyclicBarrier.await(); // 等待!
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } catch (BrokenBarrierException e) {
                     e.printStackTrace();
                 }
             }).start();
         }
     }
 }

 

8.3、Semaphore

Semaphore:信号量

抢车位!

6车---3个停车位置

 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 ​
 public class SemaphoreDemo {
     public static void main(String[] args) {
         // 线程数量,停车位!限流!
         Semaphore semaphore = new Semaphore(3);
 ​
         for (int i = 1; i <= 6 ; i++) {
             new Thread(()->{
                 try {
                     // acquire() 获取
                     semaphore.acquire();
                     System.out.println(Thread.currentThread().getName()+"抢到车位!");
                     TimeUnit.SECONDS.sleep(2);
                     System.out.println(Thread.currentThread().getName()+"离开车位!");
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }finally {
                     semaphore.release(); // release() 释放!
                 }
             },String.valueOf(i)).start();
         }
     }
 }

 

9、读写锁

ReadWriteLock

 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 ​
 /**
  * 读占锁(写锁)一次只能被一个线程占用!
  * 共享锁(读锁)多个线程可以同时占有!
  * ReadWriteLock
  * 读-读 :可以共存!
  * 读-写 :不能共存!
  * 写-写 :不能共存!
  */
 public class ReadWriteLockDemo {
     public static void main(String[] args) {
         //MyCache cache = new MyCache();
         MyCacheLock cache = new MyCacheLock();
 ​
         // 写入
         for (int i = 1; i <= 6; i++) {
             final int temp = i;
             new Thread(()->{
                 cache.put(temp+"",temp+"");
             },String.valueOf(i)).start();
         }
 ​
         // 读取
         for (int i = 1; i <= 6; i++) {
             final int temp = i;
             new Thread(()->{
                 cache.get(temp+"");
             },String.valueOf(i)).start();
         }
     }
 }
 ​
 // 加锁!
 class MyCacheLock{
 ​
     private volatile Map<String,Object> map = new HashMap<>();
     // 读写锁:更加细粒度的控制!
     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 ​
     // 存,写入的时候,只希望有一个线程写~
     public void put(String key,Object value){
 ​
         readWriteLock.writeLock().lock();
 ​
         try {
             System.out.println(Thread.currentThread().getName()+"写入"+key);
             map.put(key,value);
             System.out.println(Thread.currentThread().getName()+"写入ok!");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }
 ​
     // 取,读
     public void get(String key){
 ​
         readWriteLock.readLock().lock();
 ​
         try {
             System.out.println(Thread.currentThread().getName()+"读取"+key);
             map.get(key);
             System.out.println(Thread.currentThread().getName()+"读取ok!");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             readWriteLock.readLock().unlock();
         }
     }
 }
 ​
 ​
 /**
  * 自定义缓存
  */
 class MyCache{
 ​
     private volatile Map<String,Object> map = new HashMap<>();
 ​
     // 存,写
     public void put(String key,Object value){
         System.out.println(Thread.currentThread().getName()+"写入"+key);
         map.put(key,value);
         System.out.println(Thread.currentThread().getName()+"写入ok!");
     }
 ​
     // 取,读
     public void get(String key){
         System.out.println(Thread.currentThread().getName()+"读取"+key);
         map.get(key);
         System.out.println(Thread.currentThread().getName()+"读取ok!");
     }
 }

 

10、阻塞队列

阻塞队列:

BlockingQueue BlockingQueue 不是新的东西

什么情况下我们会使用 阻塞队列:多线程并发处理,线程池!

学会使用队列

添加、移除

四组 API

方式 抛出异常 有返回值,不抛出异常 阻塞 等待 超时等待
添加 add offer() put() offer(,,)
移除 remove poll() take() poll(,)
检测队首元素 element peek - -
 /**
  * 抛出异常
  */
 public static void test1(){
     // 队列的大小
     ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
 ​
     // java.lang.IllegalStateException: Queue full 抛出异常!
     System.out.println(blockingQueue.add("a"));
     System.out.println(blockingQueue.add("b"));
     System.out.println(blockingQueue.add("c"));
     //System.out.println(blockingQueue.add("d"));
     System.out.println(blockingQueue.element()); // 检测队首元素!
 ​
     System.out.println("-------------------");
 ​
     // java.util.NoSuchElementException 抛出异常!
     System.out.println(blockingQueue.remove());
     System.out.println(blockingQueue.remove());
     System.out.println(blockingQueue.remove());
     //System.out.println(blockingQueue.remove());
 }
 /**
  * 有返回值,不抛出异常!
  */
 public static void test2(){
     // 队列的大小!
     ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
 ​
     System.out.println(blockingQueue.offer("a"));
     System.out.println(blockingQueue.offer("b"));
     System.out.println(blockingQueue.offer("c"));
 ​
     //System.out.println(blockingQueue.offer("d")); // false 不抛出异常!
     System.out.println(blockingQueue.peek()); // 检测队首元素!
     System.out.println("-------------------");
 ​
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll()); // null 不抛出异常!
     
 }
 /**
  * 等待,阻塞(一直阻塞)
  */
 public static void test3() throws InterruptedException {
     // 队列的大小!
     ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
 ​
     // 一直阻塞
     blockingQueue.put("a");
     blockingQueue.put("b");
     blockingQueue.put("c");
     //blockingQueue.put("d");   // 队列没有位置了,一直阻塞!
 ​
     System.out.println(blockingQueue.take());
     System.out.println(blockingQueue.take());
     System.out.println(blockingQueue.take());
     System.out.println(blockingQueue.take()); // 没有这个元素,一直阻塞!
 }
 /**
  * 等待,阻塞(等待超时)
  */
 public static void test4() throws InterruptedException {
     // 队列的大小!
     ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
 ​
     // 一直阻塞
     blockingQueue.offer("a");
     blockingQueue.offer("b");
     blockingQueue.offer("c");
     //blockingQueue.offer("d",2, TimeUnit.SECONDS);  // 等待2秒就退出~
 ​
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll());
     System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS)); // 等待2秒就退出~
 }

SynchronousQueue 同步队列

没有容量,

进去一个元素,必须等待取出来之后,才能再往里面放一个元素!

put、take

 import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.TimeUnit;
 ​
 /**
  * 同步队列
  * 与其他的BlockingQueue 不一样,Synchronized 不存储元素~!
  * put了一个元素必须从里面tack()取出来,否则不能put进去值!
  */
 public class SynchronizedQueueDemo {
     public static void main(String[] args) {
 ​
         SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>(); // 同步队列
 ​
         new Thread(()->{
             try {
                 System.out.println(Thread.currentThread().getName()+"put 1");
                 synchronousQueue.put("1");
                 System.out.println(Thread.currentThread().getName()+"put 2");
                 synchronousQueue.put("2");
                 System.out.println(Thread.currentThread().getName()+"put 3");
                 synchronousQueue.put("3");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         },"A").start();
 ​
         new Thread(()->{
             try {
                 TimeUnit.SECONDS.sleep(1);
                 System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
                 TimeUnit.SECONDS.sleep(1);
                 System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
                 TimeUnit.SECONDS.sleep(1);
                 System.out.println(Thread.currentThread().getName()+synchronousQueue.take());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         },"B").start();
     }
 }

 

11、线程池(重点)

线程池:三大方法、7大参数、4种拒绝策略

池化技术

程序的运行、本质:占用系统的资源! 优化资源的使用! – – >池化技术

线程池、连接池、内存池、对象池///..... 创建、销毁。十分浪费资源

池化技术:事先准备好一些资源,有人要用,就来我这里拿,用完之后还给我。

 

线程池的好处:

  1. 降低资源的损耗

  2. 提高响应的速度

  3. 方便管理

线程复用、可以控制最大并发数、管理线程

 

线程池:三大方法

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 ​
 // Executors 工具类、3大方法
 public class Demo01 {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
         //ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
         //ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的。遇强则强、遇弱则弱!
 ​
         try {
             for (int i = 0; i < 100; i++) {
                 // 使用了线程池之后,使用线程池来创建线程
                 threadPool.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"ok");
                 });
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             // 线程池用完之后,程序结束,关闭线程池
             threadPool.shutdown();
         }
 ​
     }
 }

 

7大参数

源码分析

 public static ExecutorService newSingleThreadExecutor() {
     return new FinalizableDelegatedExecutorService
       (new ThreadPoolExecutor(1, 1,
                             0L, TimeUnit.MILLISECONDS,
                             new LinkedBlockingQueue<Runnable>()));
 }
 ​
 public static ExecutorService newFixedThreadPool(int nThreads) {
     return new ThreadPoolExecutor(nThreads, nThreads,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>());
 }
 ​
 public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE, // 21亿  OOM
                                 60L, TimeUnit.SECONDS,
                                 new SynchronousQueue<Runnable>());
 }
 ​
 // 本质:ThreadPoolExecutor
 ​
     public ThreadPoolExecutor(int corePoolSize, //  核心线程池大小
                               int maximumPoolSize, // 最大核心线程池大小
                               long keepAliveTime, // 超时了没有人调用就会释放
                               TimeUnit unit, // 超时单位
                               BlockingQueue<Runnable> workQueue, // 阻塞队列
                               ThreadFactory threadFactory, // 线程工厂,创建线程的,一般不用动
                               RejectedExecutionHandler handler) { // 拒绝策略
         if (corePoolSize < 0 ||
             maximumPoolSize <= 0 ||
             maximumPoolSize < corePoolSize ||
             keepAliveTime < 0)
             throw new IllegalArgumentException();
         if (workQueue == null || threadFactory == null || handler == null)
             throw new NullPointerException();
         this.acc = System.getSecurityManager() == null ?
                 null :
                 AccessController.getContext();
         this.corePoolSize = corePoolSize;
         this.maximumPoolSize = maximumPoolSize;
         this.workQueue = workQueue;
         this.keepAliveTime = unit.toNanos(keepAliveTime);
         this.threadFactory = threadFactory;
         this.handler = handler;
     }

手动创建一个线程池

 import java.util.concurrent.*;
 ​
 // Executors 工具类、3大方法
 ​
 /**
  * new ThreadPoolExecutor.AbortPolicy() // 银行满了,还有人进来,不处理这个人的,抛出异常
  * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里!
  * new ThreadPoolExecutor.DiscardPolicy() //队列满了,丢掉任务,不会抛出异常!
  *  new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了,尝试去和最早的竞争,也不会抛出异常!
  */
 public class Demo01 {
     public static void main(String[] args) {
         //ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
         //ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
         //ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的。遇强则强、遇弱则弱!
         // 自定义线程池! 工作 ThreadPoolExecutor
         ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                 2,
                 5,
                 3,
                 TimeUnit.SECONDS,
                 new LinkedBlockingDeque<>(3),
                 Executors.defaultThreadFactory(),
                 new ThreadPoolExecutor.DiscardOldestPolicy() // 队列满了,尝试去和最早的竞争,也不会抛出异常!
         );
 ​
         try {
             // 最大承载: Deque + max
             // 超过了 RejectedExecutionException
             for (int i = 0; i <= 9; i++) {
                 // 使用了线程池之后,使用线程池来创建线程
                 poolExecutor.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"ok");
                 });
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             // 线程池用完之后,程序结束,关闭线程池
             poolExecutor.shutdown();
         }
 ​
     }
 }

 

四种拒绝策略

 /**
  * new ThreadPoolExecutor.AbortPolicy() // 银行满了,还有人进来,不处理这个人的,抛出异常
  * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里!
  * new ThreadPoolExecutor.DiscardPolicy() //队列满了,丢掉任务,不会抛出异常!
  *  new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了,尝试去和最早的竞争,也不会抛出异常!
  */

 

小结和拓展

池的最大的大小如何去设置!

了解:IO密集型、CPU密集型:(调优)!

 import java.util.concurrent.*;
 ​
 // Executors 工具类、3大方法
 ​
 /**
  * new ThreadPoolExecutor.AbortPolicy() // 银行满了,还有人进来,不处理这个人的,抛出异常
  * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里!
  * new ThreadPoolExecutor.DiscardPolicy() //队列满了,丢掉任务,不会抛出异常!
  *  new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了,尝试去和最早的竞争,也不会抛出异常!
  */
 public class Demo01 {
     public static void main(String[] args) {
         //ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
         //ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
         //ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的。遇强则强、遇弱则弱!
         // 自定义线程池! 工作 ThreadPoolExecutor
 ​
         // 最大线程池该如何定义
         // 1、CPU 密集型 几核就是几,可以保持CPU的效率最高!
         // 2、IO 密集型 > 判断你程序中十分耗IO的线程,
         // 程序 15个大型任务  IO十分耗资源
         ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                 2,
                 Runtime.getRuntime().availableProcessors(),
                 3,
                 TimeUnit.SECONDS,
                 new LinkedBlockingDeque<>(3),
                 Executors.defaultThreadFactory(),
                 new ThreadPoolExecutor.DiscardOldestPolicy() // 队列满了,尝试去和最早的竞争,也不会抛出异常!
         );
 ​
         try {
             // 最大承载: Deque + max
             // 超过了 RejectedExecutionException
             for (int i = 0; i <= 19; i++) {
                 // 使用了线程池之后,使用线程池来创建线程
                 poolExecutor.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"ok");
                 });
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             // 线程池用完之后,程序结束,关闭线程池
             poolExecutor.shutdown();
         }
 ​
     }
 }

 

12、四大函数式接口(必须掌握)

新时代的程序员:lambda表达式、链式编程、函数式接口、Stream计算

 

函数式接口:只有一个方法的接口

 @FunctionalInterface
 public interface Runnable {
     public abstract void run();
 }
 ​
 // 泛型、枚举、反射
 // lambda表达式、链式编程、函数式接口、Stream流式计算!
 // 超级多的FunctionalInterface
 // 简化编程模型、在新版本的框架底层大量应用!
 // foreach(消费者类的函数式接口)

代码测试:

 package com.Jack.function;
 ​
 import java.util.function.Function;
 ​
 /**
  * Function 函数式接口,有一个输入参数,有一个输出
  * 只要是函数式接口 可以使用lambda表达式简化!
  */
 public class Demo01 {
     public static void main(String[] args) {
 ​
         //Function function = new Function<String, String>() {
         //    @Override
         //    public String apply(String str) {
         //        return str;
         //    }
         //};
 ​
         Function function = (str)->{return str;};
 ​
         System.out.println(function.apply("ABC"));
     }
 }

 

断定型接口:有一个输入参数,返回值只能是 布尔值!

 package com.Jack.function;
 ​
 import java.util.function.Predicate;
 ​
 /**
  * 断定性接口:有一个输入参数,返回值只能是 布尔值!
  */
 public class Demo02 {
     public static void main(String[] args) {
         // 判断字符串是否为空
         //Predicate<String> predicate = new Predicate<String>() {
         //    @Override
         //    public boolean test(String str) {
         //        return str.isEmpty();
         //    }
         //};
 ​
         Predicate<String> predicate = (str)->{return str.isEmpty();};
 ​
         System.out.println(predicate.test(""));
     }
 }

 

Consumer 消费型接口!

 package com.Jack.function;
 ​
 import java.util.function.Consumer;
 ​
 /**
  * 消费型接口:只有输入,没有返回值!
  */
 public class Demo03 {
     public static void main(String[] args) {
         //Consumer<String> consumer = new Consumer<String>() {
         //    @Override
         //    public void accept(String str) {
         //        System.out.println(str);
         //    }
         //};
 ​
         Consumer<String> consumer = (str)->{System.out.println(str);};
 ​
         consumer.accept("abc");
     }
 }

 

Supplier 供给型接口

 package com.Jack.function;
 ​
 import java.util.function.Supplier;
 ​
 /**
  * Supplier 供给型接口 没有输入,只有返回值!
  */
 public class Demo04 {
     public static void main(String[] args) {
         //Supplier<Integer> supplier = new Supplier<Integer>() {
         //    @Override
         //    public Integer get() {
         //        System.out.println("get()");
         //        return 1024;
         //    }
         //};
 ​
         Supplier<Integer> supplier = ()->{return 1024;};
 ​
         System.out.println(supplier.get());
     }
 }

 

13、Stream流式计算

大数据:存储 + 计算

集合、MySQL 本质就是存储东西的;

计算都应该交给流来操作!

 package com.Jack.stream;
 ​
 import java.util.Arrays;
 import java.util.List;
 ​
 /**
  * 题目要求:一分钟内完成此题,只能用一行代码实现!
  * 现在有5个用户!筛选:
  * 1、ID 必须是偶数
  * 2、年龄必须大于23岁
  * 3、用户名转为大写字母
  * 4、用户名字母倒着排序
  * 5、只输出一个用户!
  */
 public class Test {
     public static void main(String[] args) {
         User u1 = new User(1, "a", 21);
         User u2 = new User(2, "b", 22);
         User u3 = new User(3, "c", 23);
         User u4 = new User(4, "d", 24);
         User u5 = new User(5, "e", 25);
 ​
         // 集合就是存储
         List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
 ​
         // 计算交给Stream流
         // lambda表达式、链式编程、函数式接口、Stream流式计算
         list.stream()
                 .filter(u ->{return u.getId()%2==0;})
                 .filter(u ->{return u.getAge()>23;})
                 .map(u ->{return u.getName().toUpperCase();})
                 .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                 .limit(1)
                 .forEach(System.out::println);
     }
 }

 

14、ForkJoin

什么是ForkJoin

ForkJoin 在 JDK1.7,并发执行任务!提高效率。大数据量!

大数据:Map Reduce (把大任务拆分为小任务)

 

ForkJoin 特点:工作窃取

这个里面维护的都是双端队列

 

ForkJoin

 package com.Jack.ForkJoin;
 ​
 import java.util.concurrent.RecursiveTask;
 ​
 /**
  * 求和计算任务!
  * 3000   6000(ForkJoin)  9000(Stream并行流)
  * 如何使用 forkjoin
  * 1、forkjoinPool 通过它来执行
  * 2、计算任务 forkjoinPool.execute(ForkJoinTask task)
  * 3、计算类要继承 ForkJoinTask
  */
 public class ForkJoinDemo extends RecursiveTask<Long> {
 ​
     private Long start;
     private Long end;
 ​
     // 临界值
     private Long temp = 10000L;
 ​
     public ForkJoinDemo(Long start,Long end){
         this.start = start;
         this.end = end;
     }
 ​
     // 计算方法
     @Override
     protected Long compute() {
         if ((end-start)>0){
             Long sum = 0L;
             for (Long i = start; i <= end; i++) {
                 sum += i;
             }
             return sum;
         }else{ // forkjoin 递归
             long middle = (start + end) / 2; // 中间值
             ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
             task1.fork(); // 拆分任务,把任务压入线程队列
             ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
             task2.fork(); // 拆分任务,把任务压入线程队列
 ​
             return task1.join()+task2.join();
         }
     }
 ​
 }

测试:

 package com.Jack.ForkJoin;
 ​
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinTask;
 import java.util.stream.LongStream;
 ​
 /**
  * 同一个任务,别人高你几十倍!
  */
 public class Test {
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         //test1(); //25090
         //test2(); //13940
         test3(); // 282
     }
 ​
     // 普通程序员!
     public static void test1(){
         Long sum = 0L;
         long start = System.currentTimeMillis();
         for (Long i = 1L; i <= 10_0000_0000; i++) {
             sum += i;
         }
         long end = System.currentTimeMillis();
         System.out.println("sum="+sum+"时间:"+(end-start));
     }
 ​
     // 会 forkjoin
     public static void test2() throws ExecutionException, InterruptedException {
 ​
         long start = System.currentTimeMillis();
         ForkJoinPool forkJoinPool = new ForkJoinPool();
         ForkJoinDemo task = new ForkJoinDemo(0L, 10_0000_0000L);
         ForkJoinTask<Long> submit = forkJoinPool.submit(task);
         Long sum = submit.get();
 ​
         long end = System.currentTimeMillis();
         System.out.println("sum="+sum+"时间:"+(end-start));
     }
 ​
     // Stream 并发流 range()  rangeClosed(]
     public static void test3(){
         long start = System.currentTimeMillis();
         long sum = LongStream.rangeClosed(0L,
                 10_0000_0000L).parallel().reduce(0, Long::sum);
         long end = System.currentTimeMillis();
         System.out.println("sum="+sum+"时间:"+(end-start));
     }
 }

 

15、异步回调

Future 设计的初衷:对将来的某个事件的结果进行建模

 

 package com.Jack.Future;
 ​
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 ​
 /**
  * 异步调用: CompletableFuture
  *  异步执行
  *  成功回调
  *  失败回调
  */
 public class Demo01 {
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         // 发送这个请求 没有返回值的 Async 异步回调~
         //CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
         //    try {
         //        TimeUnit.SECONDS.sleep(2);
         //    } catch (InterruptedException e) {
         //        e.printStackTrace();
         //    }
         //    System.out.println(Thread.currentThread().getName()+"runAsync=> Void");
         //});
         //System.out.println("11111");
         //
         //completableFuture.get(); // 获取阻塞执行结果!
 ​
         // 有返回值的 supplyAsync 异步回调~
         // ajax ,成功和失败的回调!
         // 返回的是错误信息~
         CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
             System.out.println(Thread.currentThread().getName()+"supplyAsync => Integer");
             int i =  1/0;
             return 1024;
         });
         System.out.println(completableFuture.whenComplete((t, u) -> {
             System.out.println("t=>" + t); // 正常的返回结果!
             System.out.println("u=>" + u); // 错误信息:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero !
         }).exceptionally((e) -> {
             e.getMessage();
             return 233; // 可以获取到错误的返回结果!
         }).get());
 ​
         /**
          * success Code 200
          * error Code 404 500
          */
     }
 }

异步调用:CompletableFuture+parallStream()实现

16、JMM

请你谈谈你对Volactile 的理解

Volatile 是Java 虚拟机提供的轻量级的同步机制!

1、保证可见性

2、不保证原子性

3、禁止指令重排

 

什么是JMM

JMM : Java内存模型,不存在的东西,概念!约定!

关于JMM的一些同步的约定:

1、线程解锁前,必须把共享变量立刻刷回主存。

2、线程加锁前,必须读取主存中的最新值到工作内存中!

3、加锁和解锁是同一把锁

 

线程 工作内存主内存

8种操作:

内存交互操作有8种,虚拟机实现必须保证每一个操作都是原子的,不可在分的(对于double和long类 型的变量来说,load、store、read和*write操作在某些平台上允许例外)

JMM**对这八种指令的使用,制定了如下规则:**

 

问题: 程序不知道主内存的值已经被修改过了

 

17、Volatile

1、保证原子可见性

 package com.Jack.Volatile;
 ​
 import java.util.concurrent.TimeUnit;
 ​
 public class JMMDemo {
 ​
     // 不加 volatile 程序就会死循环!
     // 加 volatile 可以保证可见性!
     private volatile static int num = 0;
 ​
     public static void main(String[] args) { // main
 ​
         new Thread(()->{ // 线程1 对主内存中的变化是不知道的!
             while (num==0){
 ​
             }
         }).start();
 ​
         try {
             TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         num = 1;
         System.out.println(num);
     }
 }

 

2、不保证原子性

原子性:不可分割

线程A在执行任务的时候,不能被打扰的,也不能被分割。要么都成功,要么都失败!

 package com.Jack.Volatile;
 ​
 public class VDemo {
 ​
     private volatile static int num = 0;
 ​
     // volatile 不保证原子性!
     public static void add(){
         num++;
     }
 ​
     public static void main(String[] args) {
 ​
         // 理论上num结果应该是 20000
         for (int i = 1; i <= 20; i++) {
             new Thread(()->{
                 for (int j = 0; j < 1000; j++) {
                     add();
                 }
             }).start();
 ​
         }
         while (Thread.activeCount()>2){ // main gc
             Thread.yield();
         }
         System.out.println(Thread.currentThread().getName()+" " +num);
     }
 }

如果不加 lock 和 synchronize,怎么保证原子性!

使用原子类,解决原子性问题

 package com.Jack.Volatile;
 ​
 import java.util.concurrent.atomic.AtomicInteger;
 ​
 public class VDemo {
 ​
     //private volatile static int num = 0;
     // 原子类的 Integer
     private volatile static AtomicInteger num = new AtomicInteger();
 ​
     // volatile 不保证原子性!
     public static void add(){
         //num++;
         num.getAndIncrement(); // AtomicInteger + 1 方法, CAS
     }
 ​
     public static void main(String[] args) {
 ​
         // 理论上num结果应该是 20000
         for (int i = 1; i <= 20; i++) {
             new Thread(()->{
                 for (int j = 0; j < 1000; j++) {
                     add();
                 }
             }).start();
 ​
         }
         while (Thread.activeCount()>2){ // main gc
             Thread.yield();
         }
         System.out.println(Thread.currentThread().getName()+" " +num);
     }
 }

这些类的底层都直接和操作系统挂钩!在内存中修改值!Unsafe类是一个很特殊的存在!

 

指令重排

什么是 指令重排:你写的程序,计算机并不是按照你写的那样去执行的。

源代码-->编译器优化的重排--> 指令并行也可能会重排--> 内存系统也会重排---> 执行

处理器在进行指令重排的时候,考虑:数据之间的依赖性!

 

 int x = 1; // 1
 int y = 2; // 2
 x = x + 5; // 3
 y = x * x; // 4
 ​
 我们所期望的:1234 但是可能执行的时候回变成 2134 1324
 可不可能是 4123!

可能造成影响的结果: a b x y 这四个值默认都是 0;

线程A 线程B
x=a y=b
b=1 a=2

正常的结果: x = 0;y = 0;但是可能由于指令重排

线程A 线程B
b=1 a=2
x=a y=b

指令重排导致的诡异结果: x = 2;y = 1;

 

非计算机专业

volatile可以避免指令重排:

内存屏障。CPU指令。作用:

1、保证特定的操作的执行顺序!

2、可以保证某些变量的内存可见性 (利用这些特性volatile实现了可见性)

Volatile 是可以保持 可见性。不能保证原子性,由于内存屏障,可以保证避免指令重排的现象产生!

 

18、彻底玩转单例模式

饿汉式、DCL懒汉式,深究!

饿汉式

 package com.Jack.signle;
 ​
 /**
  * 饿汉式单例
  */
 public class Hungry {
 ​
     // 可能会浪费资源
     private byte[] data1 = new byte[1024*1024];
     private byte[] data2 = new byte[1024*1024];
     private byte[] data3 = new byte[1024*1024];
     private byte[] data4 = new byte[1024*1024];
 ​
     private Hungry(){
 ​
     }
 ​
     private final static Hungry HUNGRY = new Hungry();
 ​
     public static Hungry getInstance(){
         return HUNGRY;
     }
 }

DCL 懒汉式

 package com.Jack.signle;
 ​
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 ​
 /**
  * DCL 懒汉式单例
  */
 public class LazyMan {
 ​
     private static boolean qinjiang = false;
 ​
     private LazyMan(){
         synchronized (LazyMan.class){
             if (qinjiang==false){
                 qinjiang = true;
             }else{
                 throw new RuntimeException("不要视图使用反射破坏单例");
             }
         }
     }
 ​
     private volatile static LazyMan lazyMan; // 使用volatile 避免指令重排,保证线程之间的可见性!
 ​
     // 双重检测锁模式 的懒汉式单例 DCL 懒汉式
     public static LazyMan getInstance(){
         if (lazyMan==null){
             synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan(); // 不是一个原子性操作!
                     /**
                      * 1、分配内存空间
                      * 2、执行构造方法、初始化对象
                      * 3、把这个对象指向这个空间
                      *
                      * 123
                      * 132
                      *
                      * A
                      * B  此时LazyMan 没有完成构造
                      */
                 }
             }
         }
         return lazyMan;
     }
 ​
     /* 多线程并发
     public static void main(String[] args) {
         for (int i = 0; i < 10; i++) {
             new Thread(()->{
                 LazyMan.getInstance();
             }).start();
         }
     }*/
 ​
     public static void main(String[] args) throws Exception {
         LazyMan instance = LazyMan.getInstance();
 ​
         Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
         qinjiang.setAccessible(true);
         qinjiang.set(instance,false);
 ​
         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
         declaredConstructor.setAccessible(true);
         LazyMan instance1 = declaredConstructor.newInstance();
 ​
 ​
         System.out.println(instance);
         System.out.println(instance1);
     }
 }

静态内部类

 package com.Jack.signle;
 ​
 /**
  * 静态内部类!
  */
 public class Holder {
 ​
     private Holder(){
 ​
     }
 ​
     public static Holder getInstance(){
         return InnerClass.HOLDER;
     }
 ​
     public static class InnerClass{
         private static final Holder HOLDER = new Holder();
     }
 ​
 }

单例不安全,反射

枚举

 package com.Jack.signle;
 ​
 import java.lang.reflect.Constructor;
 ​
 /**
  * 枚举本身也是一个class类
  */
 public enum EnumSignle {
 ​
     INSTANCE;
 ​
     public EnumSignle getInstance(){
         return INSTANCE;
     }
 }
 ​
 class Test{
     public static void main(String[] args) throws Exception {
         EnumSignle instance1 = EnumSignle.INSTANCE;
         Constructor<EnumSignle> declaredConstructor = EnumSignle.class.getDeclaredConstructor(String.class, int.class);
         declaredConstructor.setAccessible(true);
         EnumSignle instance = declaredConstructor.newInstance();
 ​
         System.out.println(instance);
         System.out.println(instance1);
     }
 }

枚举最终反编译:

 // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
 // Jad home page: http://www.kpdus.com/jad.html
 // Decompiler options: packimports(3)
 // Source File Name:   EnumSingle.java
 package com.kuang.single;
 public final class EnumSingle extends Enum
 {
     public static EnumSingle[] values()
     {
         return (EnumSingle[])$VALUES.clone();
     }
     public static EnumSingle valueOf(String name)
     {
         return (EnumSingle)Enum.valueOf(com/kuang/single/EnumSingle, name);
     }
     private EnumSingle(String s, int i)
     {
         super(s, i);
     }
     public EnumSingle getInstance()
     {
         return INSTANCE;
     }
     public static final EnumSingle INSTANCE;
     private static final EnumSingle $VALUES[];
 static
     {
         INSTANCE = new EnumSingle("INSTANCE", 0);
         $VALUES = (new EnumSingle[] {
 INSTANCE
 }); }
 }

 

19、深入理解CAS

什么是 CAS

大厂你必须要深入研究底层!有所突破!修内功,操作系统,计算机网络原理!

 package com.Jack.cas;
 ​
 import java.util.concurrent.atomic.AtomicInteger;
 ​
 public class CASDemo {
 ​
     // CAS  compareAndSet  : 比较并交换!
     public static void main(String[] args) {
         AtomicInteger atomicInteger = new AtomicInteger(2020);
 ​
         // 期望
         // public final boolean compareAndSet(int expect, int update)
         // 如果我期望的值达到了,那么久更新,否则就不更新 CAS 是CPU的并发原语!
         System.out.println(atomicInteger.compareAndSet(2020, 2021));
         System.out.println(atomicInteger.get());
 ​
         atomicInteger.getAndIncrement();
         System.out.println(atomicInteger.compareAndSet(2020,2021));
         System.out.println(atomicInteger.get());
     }
 }

 

Unsafe 类

CAS : 比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么则执行操作!如果不是就 一直循环!

缺点

1、循环会耗时

2、一次性只能保证一个共享变量的原子性

3、ABA 问题

 

CAS:ABA问题(狸猫换太子)

 package com.Jack.cas;
 ​
 import java.util.concurrent.atomic.AtomicInteger;
 ​
 public class CASDemo {
 ​
     // CAS  compareAndSet  : 比较并交换!
     public static void main(String[] args) {
         AtomicInteger atomicInteger = new AtomicInteger(2020);
 ​
         // 期望
         // public final boolean compareAndSet(int expect, int update)
         // 如果我期望的值达到了,那么久更新,否则就不更新 CAS 是CPU的并发原语!
         // -----------------捣蛋的线程-----------------
         System.out.println(atomicInteger.compareAndSet(2020, 2021));
         System.out.println(atomicInteger.get());
 ​
         System.out.println(atomicInteger.compareAndSet(2021,2020));
         System.out.println(atomicInteger.get());
 ​
         // -----------------捣蛋的线程-----------------
         System.out.println(atomicInteger.compareAndSet(2020,6666));
         System.out.println(atomicInteger.get());
     }
 }

 

20、原子应用

解决 ABA 问题,引入原子引用!对应的思想:乐观锁!

带版本号的 原子操作!

 package com.Jack.cas;
 ​
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicStampedReference;
 ​
 public class CASDemo {
 ​
     // AtomicStampedReference 注意,如果泛型是一个包装类,注意对象的引用问题!
 ​
     //正常业务操作,这里面比较的是一个个对象
     static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
 ​
     // CAS  compareAndSet  : 比较并交换!
     public static void main(String[] args) {
 ​
         new Thread(()->{
             int stamp = atomicStampedReference.getStamp();  // 获得版本号!
             System.out.println("a1=>"+stamp);
 ​
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
 ​
             atomicStampedReference.compareAndSet(1,2,
                     atomicStampedReference.getStamp(),
                     atomicStampedReference.getStamp()+1);
             System.out.println("a2=>"+atomicStampedReference.getStamp());
 ​
             System.out.println(atomicStampedReference.compareAndSet(2, 1,
                     atomicStampedReference.getStamp(),
                     atomicStampedReference.getStamp() + 1));
             System.out.println("a3=>"+atomicStampedReference.getStamp());
         },"a").start();
 ​
         // 乐观锁的原理相同!
         new Thread(()->{
             int stamp = atomicStampedReference.getStamp();  // 获得版本号!
             System.out.println("b1=>"+stamp);
 ​
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
 ​
             System.out.println(atomicStampedReference.compareAndSet(1, 6,
                     atomicStampedReference.getStamp(),
                     atomicStampedReference.getStamp() + 1));
             System.out.println("b2=>"+atomicStampedReference.getStamp());
         },"b").start();
     }
     /*
         AtomicInteger atomicInteger = new AtomicInteger(2020);
         
         // 期望
         // public final boolean compareAndSet(int expect, int update)
         // 如果我期望的值达到了,那么久更新,否则就不更新 CAS 是CPU的并发原语!
         // -----------------捣蛋的线程-----------------
         System.out.println(atomicInteger.compareAndSet(2020, 2021));
         System.out.println(atomicInteger.get());
         
         System.out.println(atomicInteger.compareAndSet(2021,2020));
         System.out.println(atomicInteger.get());
         
         // -----------------捣蛋的线程-----------------
         System.out.println(atomicInteger.compareAndSet(2020,6666));
         System.out.println(atomicInteger.get());
      */
 }

注意:

Integer 使用了对象缓存机制,默认范围是 -128 ~ 127 ,推荐使用静态工厂方法 valueOf 获取对象实

例,而不是 new,因为 valueOf 使用缓存,而 new 一定会创建新的对象分配新的内存空间;

 

21、各种锁的理解

1、公平锁、非公平锁

公平锁: 非常公平, 不能够插队,必须先来后到!

非公平锁:非常不公平,可以插队 (默认都是非公平)

 /**
  * Creates an instance of {@code ReentrantLock}.
  * This is equivalent to using {@code ReentrantLock(false)}.
  */
 public ReentrantLock() {
     sync = new NonfairSync();
 }
 ​
 public ReentrantLock(boolean fair) {
     sync = fair ? new FairSync() : new NonfairSync();
 }

 

2、可重入锁

可重入锁(递归锁)

Synchronized

 package com.Jack.lock;
 ​
 public class Demo01 {
     public static void main(String[] args) {
         Phone phone = new Phone();
 ​
         new Thread(()->{
             phone.sms();
         },"A").start();
 ​
         new Thread(()->{
             phone.sms();
         },"B").start();
     }
 }
 class Phone{
 ​
     public synchronized void sms(){
         System.out.println(Thread.currentThread().getName()+"sms");
         call(); // 这里也有锁!
     }
 ​
     public synchronized void call(){
         System.out.println(Thread.currentThread().getName()+"call");
     }
 }

 

Lock

 package com.Jack.lock;
 ​
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         Phone2 phone = new Phone2();
 ​
         new Thread(()->{
             phone.sms();
         },"A").start();
 ​
         new Thread(()->{
             phone.sms();
         },"B").start();
     }
 }
 class Phone2{
     Lock lock = new ReentrantLock();
 ​
     public void sms(){
 ​
         lock.lock(); // 细节问题:lock.lock();  lock.unlock(); lock锁必须配对,否则就会死在里面
         lock.lock();
         
         try {
             System.out.println(Thread.currentThread().getName()+"sms");
             call(); // 这里也有锁!
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
             lock.unlock();
         }
     }
 ​
     public void call(){
 ​
         lock.lock();
 ​
         try {
             System.out.println(Thread.currentThread().getName()+"call");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 }

 

3、自旋锁

SpinLock

我们来自定义一个锁测试

 package com.Jack.lock;
 ​
 import java.util.concurrent.atomic.AtomicReference;
 ​
 /**
  * 自旋锁
  */
 public class SpinlockDemo {
 ​
     // int 0
     // Thread null
     AtomicReference<Thread> atomicReference = new AtomicReference<>();
 ​
     // 加锁
     public void mylock(){
         Thread thread = new Thread();
         System.out.println(Thread.currentThread().getName()+"--> mylock");
 ​
         //自旋锁
         while (atomicReference.compareAndSet(null,thread)){
 ​
         }
     }
 ​
     // 解锁
     // 加锁
     public void myUnlock(){
         Thread thread = new Thread();
         System.out.println(Thread.currentThread().getName()+"--> myUnlock");
         atomicReference.compareAndSet(thread,null);
     }
 }

 

测试

 package com.Jack.lock;
 ​
 import java.util.concurrent.TimeUnit;
 ​
 public class TestSpinLock {
     public static void main(String[] args) {
         //ReentrantLock reentrantLock = new ReentrantLock();
         //reentrantLock.lock();
         //reentrantLock.unlock();
 ​
         // 底层使用 CAS 自旋锁
         SpinlockDemo lock = new SpinlockDemo();
 ​
         new Thread(()->{
             lock.mylock();
 ​
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }finally {
                 lock.myUnlock();
             }
 ​
         },"T1").start();
 ​
         new Thread(()->{
             lock.mylock();
 ​
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }finally {
                 lock.myUnlock();
             }
 ​
         },"T2").start();
     }
 }

 

4、死锁

死锁是什么?

死锁测试,怎么排除死锁:

 package com.Jack.lock;
 ​
 import java.util.concurrent.TimeUnit;
 ​
 public class DeadLockDemo {
     public static void main(String[] args) {
 ​
         String lockA = "lockA";
         String lockB = "lockB";
 ​
         new Thread(new MyThread(lockA,lockB),"T1").start();
         new Thread(new MyThread(lockB,lockA),"T2").start();
     }
 }
 class MyThread implements Runnable{
 ​
     private String lockA;
     private String lockB;
 ​
     public MyThread(String lockA, String lockB) {
         this.lockA = lockA;
         this.lockB = lockB;
     }
 ​
     @Override
     public void run() {
         synchronized (lockA){
             System.out.println(Thread.currentThread().getName()+"lockA=>"+lockA+"=>get"+lockB);
             try {
                 TimeUnit.SECONDS.sleep(2);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
 ​
             synchronized (lockB){
                 System.out.println(Thread.currentThread().getName()+"lockB=>"+lockB+"=>get"+lockA);
             }
         }
     }
 }

 

解决问题

1、使用 jps -l 定位端口号

2、使用 jstack 查看进程号 找到死锁问题

 

面试、工作中!拍查问题:

1、日志

2、堆栈

 

标签:JUC,Thread,编程,System,并发,println,new,public,out
来源: https://www.cnblogs.com/zhaostudy/p/16342579.html