JUC进阶

ShanHai山海

已于 2023-03-08 09:39:44 修改

阅读量113

点赞数

分类专栏： Java从零开始文章标签： java jvm 开发语言

于 2022-08-01 08:37:35 首次发布

本文链接：https://blog.csdn.net/qq_44787933/article/details/126093697

版权

Java从零开始专栏收录该内容

30 篇文章 4 订阅

订阅专栏

多线程进阶=>JUC并发编程

什么是JUC？

java.util工具包，包，分类

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

线程和进程

进程：一个程序（QQ.exe Music.exe）的集合

一个进程往往可以包含多个线程，至少包含一个！

java默认有几个线程？ 2个 main、GC

线程：开了一个oneNote，写字，自动保存（线程负责

）

对于Java而言：Thread、Runnable、Callable

   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 test1 {
    public static void main(String[] args) {
        //获取CPU的核数
        //CPU 密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());//12
    }
}

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

线程有几个状态

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

wait/sleep区别

1.来自不同的类

wait=>Object

sleep=>Thread

2.关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放！

3.使用的范围不同

wait：wait必须在同步代码块中

sleep：可以在任何地方睡

4.是否需要捕获异常

wait不需要捕获异常（中断异常：所有的锁都会有中断异常）

sleep需要捕获异常

Lock()锁（重点）

传统 synchronized

package com.example.juc.demo01;

/**
 * @author swh
 * @date 2022/7/26 20:44
 */

import com.sun.org.apache.xml.internal.dtm.ref.sax2dtm.SAX2DTM2;

/**
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 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 < 60; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
//资源类OOP
class Ticket{
    //属性、方法
    private int number = 50;
    //卖票的方式
    //synchronized本质：队列，锁
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票，剩余"+number);
        }
    }

}

Lock 接口

**公平锁：**十分公平；可以先来后到

**非公平锁：**十分不公平；可以插队（默认非公平锁）

package com.example.juc.demo01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author swh
 * @date 2022/7/26 21:07
 */

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类、把资源类丢入线程
        Ticket2 ticket2 = new Ticket2();

        //@FunctionalInterface 函数式接口,jdk1.8  lambda表达式(参数)->{代码}
        new Thread(()->{for (int i = 0; i < 60; i++) ticket2.sale();},"A").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket2.sale();},"B").start();
        new Thread(()->{for (int i = 0; i < 60; i++) ticket2.sale();},"C").start();
    }
}
//lock三部曲
//1、new ReentrantLock();
//2、lock.lock();加锁
//finally=>lock.unlock();解锁
class Ticket2{
    //属性、方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    public synchronized void sale(){

        lock.lock();//加锁
        try {
            //业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"剩余"+number+""票+"卖出了"+(50-number--)+"票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();//解锁
        }
    }
}

Synchronized 和 Lock 区别

1、Synchronized 内置的关键字；Lock 是一个java类

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

3、Synchronized 会自动释放锁；Lock 必须要手动释放锁！如果不释放锁，死锁

4、Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock 就不一定会等待下去

5、Synchronized 可重入锁，不可以中断的，非公平；Lock 可重入锁，不可以中断的，可以判断锁，非公平（可以自己设置）

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

锁是什么？如何判断锁的是谁

生产者和消费者问题

生产者和消费者问题 Synchronized版

package com.example.juc.pc;

/**
 * @author swh
 * @date 2022/7/27 9:14
 */

/**
 * 线程之间的通信问题：生产者和消费者问题！   等待唤醒，通知唤醒
 * 线程交替执行   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判断

package com.example.juc.pc;

/**
 * @author swh
 * @date 2022/7/27 9:43
 */

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;
    //+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

Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();
.....
notFull.await();
......
notEmpty.signal();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CaKhNli-1659314192115)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658887628539.png)]

package com.example.juc.pc;

import java.util.Locale;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author swh
 * @date 2022/7/27 10:22
 */

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        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 Data3 { //数字  资源类
    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 精准的通知和唤醒线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dSNM4cBb-1659314192116)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658890411169.png)]

代码测试：

package com.example.juc.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author swh
 * @date 2022/7/27 10:55
 */

public class D {
    public static void main(String[] args) {
        Data4 data = new Data4();
        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 Data4{//资源类

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1;//1A 2B 3C
    public void printA(){
        lock.lock();
        try {
            //业务:判断->执行->通知
            while (number != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>A");
            number = 2;
            condition2.signal();//唤醒指定线程  B
        } 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");
            number = 3;
            condition3.signal();//唤醒指定线程  C
        } 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");
            number = 1;
            condition1.signal();//唤醒指定线程  A
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OlfNnDRY-1659314192117)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658892056463.png)]

8锁现象

深刻理解我们的锁

package com.example.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 11:23
 */
/*
* 1）标准情况下，两个线程打印   sms  call
* 2)Sms延迟4秒，两个线程打印   sms  call
* */
//8锁：就是关于锁的8个问题
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{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sms");
    }
    public synchronized void call(){
        System.out.println("call");
    }
}

package com.example.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 11:23
 */
//8锁：就是关于锁的8个问题
    /*
    * 3)增加一个普通方法后     hello  sms
    * 4)两个对象，两个同步方法  call   sms
    * */
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(()->{
            phone1.hello();
        },"B").start();
    }

}

class Phone2{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁调用
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sms");
    }
    public synchronized void call(){
        System.out.println("call");
    }

    public void hello(){
        System.out.println("hello");
    }
}

package com.example.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 11:23
 */
/*
* 5）两个静态的同步方法，只有一个对象  sms  call
* 6）两个静态的同步方法，两个对象  sms  call
* */
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();
    }

}

class Phone3{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁调用
//   static类一加载就有了！锁的class模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sms");
    }
    public static synchronized void call(){
        System.out.println("call");
    }

}

package com.example.juc.lock8;

import com.example.juc.pc.A;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 11:23
 */
/*
* 7）一个静态的同步方法，一个普通的同步方法，只有一个对象   call  sms
* 8）一个静态的同步方法，一个普通的同步方法，两个对象   call   sms
* */
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(()->{
            phone1.call();
        },"B").start();
    }

}

class Phone4{

//   静态同步方法，锁的是Class模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sms");
    }
//    普通同步方法，锁的是调用者
    public synchronized void call(){
        System.out.println("call");
    }

}

小结

new this 具体的一个手机

static Class 唯一的一个模板

集合类不安全

List 不安全

package com.example.juc.unsafe;


import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author swh
 * @date 2022/7/27 14:21
 */

public class ListTest {
    public static void main(String[] args) {
//        并发下ArrayList 不安全的
        /*
        *  ConcurrentModificationException  并发修改异常
        * 解决方案:
        * 1、List<String> list = new Vector<>();
        * 2、 List<String> list =Collections.synchronizedList(new ArrayList<>());
        * 3、List<String> list =new CopyOnWriteArrayList<>();
         */
//        CopyOnWrite  写入时复制   COW  计算机程序设计领域的一种优化策略
//        多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
//        在写入的时候避免覆盖，造成数据问题
//        读写分离
//        CopyOnWriteArrayList  比  Vector   强在哪里？
        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、Vector

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJCzCtAt-1659314192119)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658904593154.png)]

2、CopyOnWriteArrayList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qn8K9Fhl-1659314192120)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658905175443.png)]

Set 不安全

package com.example.juc.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @author swh
 * @date 2022/7/27 15:09
 */
public class SetTest {
    public static void main(String[] args) {
        /*
         *  ConcurrentModificationException  并发修改异常
         * 解决方案:
         * 1、 Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2、 Set<String> set = new CopyOnWriteArraySet<>();
         */
//        Set<String> set = new HashSet<>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();

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

hashSet底层是什么？

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


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

Map 不安全

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V5MI84sE-1659314192121)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658907332929.png)]

package com.example.juc.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author swh
 * @date 2022/7/27 15:31
 */
//ConcurrentModificationException   并发修改异常
public class MapSet {
    public static void main(String[] args) {
        //map  是这样用的吗？ 不是，工作中不用HashMap
        //默认等价于什么？  new HashMap<>(16,0.75)
        /*
        * 解决方案：
        * 1） Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        * 2)  Map<String, String> map = new ConcurrentHashMap<>();
        * */
//        Map<String, String> map = new HashMap<>();
//        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        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();
        }
    }
}

Callable(简单)

与Runnable的不同

可以有返回值
可以抛出异常
方法不同，run() | call()

代码测试;

package com.example.juc.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author swh
 * @date 2022/7/27 15:57
 */

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();//怎么启动Callable

        MyThread thread = new MyThread();//实现Callable接口的类
        FutureTask futureTask = new FutureTask(thread);
        //适配类  FutureTask
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存，效率高
        Integer o = (Integer) futureTask.get();//这个get方法可能会产生阻塞！ 把他放在最后一层
        //或者使用异步通信来处理
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println("call");
        //耗时的操作
        return 1024;
    }
}
//call    1024

细节:

有缓存
结果可能需要等待，会阻塞!

底层分析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mEODQrra-1659314192122)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658910596231.png)]

常用的辅助类(必会)

CountDownLatch

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-llPPbe78-1659314192123)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658911487776.png)]

package com.example.juc.auxiliary;

import java.util.concurrent.CountDownLatch;

/**
 * @author swh
 * @date 2022/7/27 16:46
 */
//计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"出去");
                countDownLatch.countDown(); //-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("关门");

    }
}

原理：

countDownLatch.countDown(); //数量-1

countDownLatch.await();//等待计数器归0，然后再向下执行

每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！

CyclicBarrier

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-95GSX1aq-1659314192124)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658912481941.png)]

加法计数器

package com.example.juc.auxiliary;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author swh
 * @date 2022/7/27 17:02
 */

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /*
        * 集齐七颗龙召唤神龙
        * */
//        召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,new Thread(()->{
            System.out.println("召唤龙珠成功！");
        }));
        for (int i = 1; i <= 7; i++) {
            //Lambda表达式通过final修饰的能操作到i
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个");

                try {
                    cyclicBarrier.await();//等待执行到指定数量
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            }).start();
        }
    }
}

Semaphore

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fZDE598F-1659314192125)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658913210490.png)]

package com.example.juc.auxiliary;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 17:15
 */

public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量：停车位!  限流
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6; i++) {

            new Thread(() -> {
                //acquire()  得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"进去");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();  //release()  释放
                }

            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire(); 获得假设如果已经满了，等待，等待被释放为止！

semaphore.release(); 释放会将当前的信号量释放+1，然后唤醒等待的线程！

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

读写锁

ReadWriteLock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hw60YG66-1659314192126)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658919566264.png)]

package com.example.juc.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author swh
 * @date 2022/7/27 19:01
 */

public class ReadWriteLockDemo {
    public static  void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();
        //存，写
        for (int i = 0;i < 9;i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读，取
        for (int i = 0;i < 9;i++) {
            final int temp = i;
            new Thread(()->{
                myCache.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()+"写入完毕" );
        } 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 );
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完毕" );
        } 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()+"写入完毕" );
    }

    //取，读，所有人都可以读
    public void get(String key){
            System.out.println(Thread.currentThread().getName()+"读取"+key );
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完毕" );

    }
}

阻塞队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hbVXl0Oa-1659314192127)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658921490743.png)]

阻塞队列：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PWMH3c3l-1659314192128)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658922174190.png)]

BlockingQueue

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6xSuyGZf-1659314192129)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658922352982.png)]

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！

学会使用队列

添加，移除

四组API

方式	抛出异常	有返回值，不会抛出异常	阻塞等待	超时等待
添加	add	offer	put	offer(…)
移除	remove	poll	take	poll(.)
检测队首元素	element	peek	-	-

package com.example.juc.bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/27 19:34
 */

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //test1();
        //test2();
        //test3();
        test4();
    }
    /*
    * 抛出异常
    * */
    public static void test1(){
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.add("A"));
        System.out.println(arrayBlockingQueue.add("B"));
        System.out.println(arrayBlockingQueue.add("C"));
        System.out.println("----------------------------");
        //IllegalStateException : Queue full抛出异常
        //System.out.println(arrayBlockingQueue.add("D"));
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
    }

    /*
     * 不抛出异常
     * */
    public static void test2(){
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.offer("A"));
        System.out.println(arrayBlockingQueue.offer("B"));
        System.out.println(arrayBlockingQueue.offer("C"));
      //System.out.println(arrayBlockingQueue.offer("D"));  //false 不能抛出异常
        System.out.println("-----------------------------------");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());//null 不抛出异常
    }

    /*
    *  等待，阻塞（一直阻塞）
    * */
    public static void test3() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        arrayBlockingQueue.put("A");
        arrayBlockingQueue.put("B");
        arrayBlockingQueue.put("C");
        //arrayBlockingQueue.put("D");//队列没有位置，一直阻塞
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
    }
    /*
    *  等待，阻塞（等待超时）
    * */
    public static void test4() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.offer("A"));
        System.out.println(arrayBlockingQueue.offer("B"));
        System.out.println(arrayBlockingQueue.offer("C"));
        System.out.println(arrayBlockingQueue.offer("D", 2,TimeUnit.SECONDS));//等待超过2秒就退出
        System.out.println("--------------------------------");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
    }
}

SynchronousQueue 队列

没有容量进去一个元素，必须等待取出来之后，才能再往里面放一个元素！

put take

package com.example.juc.bq;


import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/28 8:57
 */
/*
* 同步队列
* 和其他的BlockingQueue 不一样，SynchronousQueue 不存储元素
* put了一个元素，必须先从里面take取出来，否则不能再put进去值
* */
public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingDeque = new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                blockingDeque.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                blockingDeque.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                blockingDeque.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+blockingDeque.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+blockingDeque.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"->"+blockingDeque.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

线程池（重点）

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

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！=>池化技术

线程池，jdbc连接池，内存池，对象池·······

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

线程池的好处：线程复用、可以控制最大并发数，管理线程

1、降低资源的消耗

2、提高响应的速度

3、方便管理

3大方法

package com.example.juc.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author swh
 * @date 2022/7/28 9:33
 */
//Executors 工具类、三大方法
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 < 10; 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,
                                  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;
}

阿里巴巴代码规范：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NYpCPyEH-1659314192131)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658973296354.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zWOO9JE8-1659314192133)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658979116649.png)]

四种拒绝策略

/*
    * new ThreadPoolExecutor.AbortPolicy()  线程池满了，还有线程进来，不处理，抛出异常
    * new ThreadPoolExecutor.CallerRunsPolicy()  哪里来的回哪里去，一般会回到主线程main
    * new ThreadPoolExecutor.DiscardPolicy()   队列满了，丢掉任务，不会抛出异常
    * new ThreadPoolExecutor.DiscardOldestPolicy()  队列满了，尝试和最早的竞争，也不会抛出异常
     * */

package com.example.juc.pool;

import java.util.concurrent.*;

/**
 * @author swh
 * @date 2022/7/28 9:33
 */
//Executors 工具类、三大方法
    /*
    * new ThreadPoolExecutor.AbortPolicy()  线程池满了，还有线程进来，不处理，抛出异常
    * new ThreadPoolExecutor.CallerRunsPolicy()  哪里来的回哪里去，一般会回到主线程main
    * new ThreadPoolExecutor.DiscardPolicy()   队列满了，丢掉任务，不会抛出异常
    * new ThreadPoolExecutor.DiscardOldestPolicy()  队列满了，尝试和最早的竞争，也不会抛出异常
     * */
public class Demo02 {
    public static void main(String[] args) {
//        自定义线程池
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()//线程池满了，还有线程进来，不处理，抛出异常
        );
//        最大承载数量：最大线程数+阻塞队列
        try {
            for (int i = 0; i < 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"   ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }
}

小结与扩展

面试题常问：

最大线程到底该如何定义？（CPU密集型、IO密集型调优）

1、CUP 密集型

几核CPU，就定义为几，可以保持CPU的效率最高！

Runtime.getRuntime().availableProcessors();//获取CPU的核数

2、IO 密集型

判断程序中特别消耗IO的线程数量。大于这个数量即可。

四大函数式接口（必须掌握）

新时代程序员必须掌握的几种编程方式：lambda表达式、链式编程、函数式接口，Stream流式计算

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

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
//超级多FunctionalInterface
//简化编程模型，在新版本的框架底层大量应用
//foreach(消费者类型的函数式接口)

Function 函数式接口

package com.example.juc.function;

import java.util.function.Function;

/**
 * @author swh
 * @date 2022/7/28 14:19
 */

/*
* Function函数型接口
* 有一个输入参数，有一个输出
* （只要是函数式接口，都可以用lambda表达式简化）
* */
public class Demo01 {
    public static void main(String[] args) {
        //
       /* Function function = new Function<String,String>() {
            @Override
            public String apply(String s) {
                return s;
            }
        };*/
        Function<String,String> function =(s)->{return s;};
    }
}

Predicate 断定型接口

package com.example.juc.function;

import java.util.function.Predicate;

/**
 * @author swh
 * @date 2022/7/28 14:29
 */
/*
* 断定型接口
* 有一个输入参数，返回值只能是布尔值
* */
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("s"));
    }
}

Consumer 消费型接口

package com.example.juc.function;

import java.util.function.Consumer;

/**
 * @author swh
 * @date 2022/7/28 14:39
 */

/*
 * 消费型接口：只有输入，没有返回值
 * */
public class Demo03 {
    public static void main(String[] args) {
     /*   Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };*/
        Consumer<String> consumer=s->{
            System.out.println(s);
        };
        consumer.accept("ss");
    }
}

Supplier 供给型接口

package com.example.juc.function;

import java.util.function.Supplier;

/**
 * @author swh
 * @date 2022/7/28 14:45
 */
/*
* 供给型接口
* 没有参数，只有返回值
* */
public class Demo04 {
    public static void main(String[] args) {
       /* Supplier supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "123";
            }
        };*/
        Supplier supplier =()->{return "123";};
        System.out.println(supplier.get());
    }
}

Stream流式计算

package com.example.juc.stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author swh
 * @date 2022/7/28 14:55
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

package com.example.juc.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Locale;

/**
 * @author swh
 * @date 2022/7/28 14:55
 */
/*
* 题目要求：一分钟内完成此题，只能用一行代码实现
* 现在有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(6, "e", 25);
        //集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);

        //计算交给stream流
        //链式编程，lambda表达式，函数式接口，stream流式计算    都有涉及到
        list.stream()
                .filter(user->{return user.getId()%2==0;})
                .filter(user->{return user.getAge() > 23;})
                .map(user->{return user.getName().toUpperCase(Locale.ROOT);})
                .sorted((user1,user2)->{return user2.compareTo(user1);})
                .limit(1)
                .forEach(System.out::println);


    }
}

ForkJoin

什么是ForkJoin？

ForkJoin在JDK1.7，并行执行任务！提高效率，大数据量！

大数据：Map Reduce（把大任务拆分成小任务）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KY8ITO7x-1659314192136)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658994603109.png)]

ForkJoin特点：工作窃取

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0unnEwe3-1659314192137)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658994730202.png)]

ForkJoin

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C9cSvOpy-1659314192138)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658997387390.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Emf1lfbI-1659314192139)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1658997691239.png)]

package com.example.juc.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * @author swh
 * @date 2022/7/28 15:55
 */
/*
* 求和计算任务
* 3      6(ForkJoin)      9(Stream并行流)
* */
public class ForkJoinDemo extends RecursiveTask<Long> {

    private Long start;
    private Long end;

    //临界值
    private Long temp = 1000000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
/*
* 如何使用ForkJoin
* 1、forkJoinPool 通过它来执行
* 2、计算任务forkJoinPool.execute(ForkJoinTask task)
* 3、计算类继承ForkJoinTask
* */

    //计算方法
    @Override
    protected Long compute() {
        if ((end-start) < temp){
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else {//分支合并计算
            long mid = (start + end) / 2;
            ForkJoinDemo fork1 = new ForkJoinDemo(start, mid);
            fork1.fork();//拆分任务，把任务压入线程队列
            ForkJoinDemo fork2 = new ForkJoinDemo(mid+1, end);
            fork2.fork();//拆分任务，把任务压入线程队列
           return fork1.join() + fork2.join();
        }
    }



/*    public static void main(String[] args) {
       3等   int a = 0;
        for (int i = 0; i < 10_0000_0000; i++) {
            a += i;
        }
        System.out.println(a);
    }*/
}

测试类：

package com.example.juc.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/**
 * @author swh
 * @date 2022/7/28 16:59
 */

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1();//5774
        //test2();//6913   由于本人电脑系统过于强大，导致测试结果没达到预想值
        test3();//136
    }
    //普通程序员
    public static void test1(){
        Long sum1 = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000L; i++) {
             sum1 += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum1 = "+sum1+"时间："+(end - start));
    }

    //会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum2 = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum2 = "+sum2+"时间："+(end - start));
    }

    //用stream并行流
    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));
    }
}

异步回调

Future

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3czArQbK-1659314192140)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659007614023.png)]

package com.example.juc.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/28 19:23
 */
/*
* 异步调用：CompletableFuture
*   异步执行
*   成功回调
*   失败回调
* */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
/*        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("123456");
        completableFuture.get();//获取阻塞执行结果*/

        //有返回值的异步回调  supplyAsync
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            int i = 1/0;
            return 1024;
        });
        //   t  正常的返回结果
        //   u  错误信息 java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        System.out.println(completableFuture.whenComplete((t,u)->{
            System.out.println("t-->"+t+"    "+"u-->"+u);
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;
        }).get());
    }
}

JMM

请你谈谈你对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM:java内存模型，不存在东西，概念！约定！

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

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

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

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

线程 工作内存、主内存

8种操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YEDaSatX-1659314192141)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659010896395.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NkHSHMtj-1659314192142)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659011099214.png)]

lock(锁定)，作用于主内存中的变量，把变量标识为线程独占的状态。
read(读取)，作用于主内存的变量，把变量的值从主内存传输到线程的工作内存中，以便下一步的load操作使用。
load(加载)，作用于工作内存的变量，把read操作主存的变量放入到工作内存的变量副本中。
use(使用)，作用于工作内存的变量，把工作内存中的变量传输到执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
assign(赋值)，作用于工作内存的变量，它把一个从执行引擎中接受到的值赋值给工作内存的变量副本中，每当虚拟机遇到一个给变量赋值的字节码指令时将会执行这个操作。
store(存储)，作用于工作内存的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用。
write(写入)：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。
unlock(解锁)：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

我再补充一下JMM对8种内存交互操作制定的规则：

不允许read、load、store、write操作之一单独出现，也就是read操作后必须load，store操作后必须write。
不允许线程丢弃他最近的assign操作，即工作内存中的变量数据改变了之后，必须告知主存。
不允许线程将没有assign的数据从工作内存同步到主内存。
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过load和assign操作。
一个变量同一时间只能有一个线程对其进行lock操作。多次lock之后，必须执行相同次数unlock才可以解锁。
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值。在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值。
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量。
一个线程对一个变量进行unlock操作之前，必须先把此变量同步回主内存。

Volatile

1、保证可见性

package com.example.juc.volatiletest;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/29 9:05
 */

public class JMMDemo {
    //不加 volatile 程序就会死循环
    //加  volatile  可以保证可见性
    private static volatile int num = 0;

    public static void main(String[] args) {//主线程


        new Thread(() -> {//线程1   没加volatile之前，对主存中的变化是不清楚的
            while (num == 0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 2;
        System.out.println(num);
    }
}

2、不保证原子性

原子性：不可分割

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

package com.example.juc.volatiletest;

/**
 * @author swh
 * @date 2022/7/29 9:22
 */
//不保证原子性
public class VolatileDemo {

    //volatile不保证原子性
    private volatile static int num = 0;

    private static void add(){
        num++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; 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 -->" + num);

    }
}

如果不加lock和synchronized，怎么保证原子性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9BZtCHWm-1659314192143)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659058412645.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jfjVyMYz-1659314192144)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659058654475.png)]

package com.example.juc.volatiletest;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author swh
 * @date 2022/7/29 9:22
 */
//不保证原子性
public class VolatileDemo {

    //volatile不保证原子性
    //原子类的Integer
    private  static AtomicInteger num = new AtomicInteger();

    private static void add(){
        //num++;//不是一个原子性操作
        num.getAndIncrement();//AtomicInteger  +1 方法，CAS
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; 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 -->" + num);

    }
}

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

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的逻辑顺序去执行的！

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

处理器在进行指令重排的时候，考虑：数据之间的依赖性问题！

int x = 1;//1
int y = 2;//2
x = x + 5;//3
y = x * x;//4

/*
我们所期望的：1234    但是可能执行的 2134  1324
不可能执行的：4123
*/

可能造成影响的结果: abxy这四个值默认都是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实现了可见性）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fp0G0aX9-1659314192145)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659061775502.png)]

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

彻底玩转单例模式

饿汉式

package com.example.juc.single;

/**
 * @author swh
 * @date 2022/7/29 10:34
 */
//饿汉式单例
public class Hungry {
    //可能会浪费空间
    private byte[] date1 = new byte[1024*1024];
    private byte[] date2 = new byte[1024*1024];
    private byte[] date3 = new byte[1024*1024];
    private byte[] date4 = new byte[1024*1024];
    private Hungry(){

    }
    private final static Hungry HUNGRY =new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

DCL懒汉式

package com.example.juc.single;

import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * @author swh
 * @date 2022/7/29 10:39
 */
//懒汉式单例模式
public class LazyMan {

    private static boolean qinjiang = false;

    private LazyMan() {

            if (qinjiang == false) {
               qinjiang = true;
            }else {
                throw new RuntimeException("不要试图用反射破坏造成异常");
        }
    }

    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例   DCL懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();//不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        //LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器、破坏私有
        LazyMan instance = declaredConstructor.newInstance();//创建一个新的对象

        qinjiang.set(instance,false);
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }
}
/*
 * 1、分配内存空间
 * 2、执行构造方法、初始化对象
 * 3、把这个对象指向这个空间
 *
 * 123
 * 132  A
 *      B // 此时lazyMan还没有完成构造
 * */

静态内部类

package com.example.juc.single;
/**
 * @author swh
 * @date 2022/7/29 10:52
 */
//静态内部类
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.example.juc.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum是什么？   本身也是一个Class类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
//Cannot reflectively create enum objects
class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();


        System.out.println(instance1);
        System.out.println(instance2);
    }
}

深入理解CAS

什么是CAS

大厂必须深入研究底层！有所突破！

package com.example.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author swh
 * @date 2022/7/29 13:07
 */

public class CASDemo{
    //CAS   compareAndSet  比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

                                               //期望         更新
        //public final boolean compareAndSet(int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新  CAS 是CPU的并发原语！
        System.out.println(atomicInteger.compareAndSet(1, 2));
        System.out.println(atomicInteger.get());
        
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(1, 2));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W2USLsIL-1659314192146)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659072091632.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q851JlGG-1659314192147)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659072331992.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5MC53xNA-1659314192149)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659072493357.png)]

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

缺点：

1、循环会耗时

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

3、ABA问题

CAS：ABA问题（狸猫换太子）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4YTsUUM2-1659314192150)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659073144856.png)]

package com.example.juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author swh
 * @date 2022/7/29 13:07
 */

public class ABADemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        //对于我们平时写的SQL：乐观锁！
        //===========捣乱的线程=============
        System.out.println(atomicInteger.compareAndSet(1, 2));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2, 1));
        System.out.println(atomicInteger.get());

        //===========期望的线程=============
        System.out.println(atomicInteger.compareAndSet(1, 3));
        System.out.println(atomicInteger.get());
    }
}

原子引用

解决ABA问题，引入原子引用！对应的思想，乐观锁

带版本号的原子操作！

Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法value of 获取对象实例，而不是new，因为value of 使用缓存，而new 一定会创建新的对象分配新的内存空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6EyYio5e-1659314192152)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659075568894.png)]

package com.example.juc.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author swh
 * @date 2022/7/29 13:47
 */

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

        //AtomicStampedReference 注意：如果泛型是一个包装类，注意对象的引用问题

        //正常业务操作，里面比较的都是对象
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(10, 1);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("A1-->"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(10, 20, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("A2-->"+atomicStampedReference.getStamp());

            System.out.println(atomicStampedReference.compareAndSet(20, 10, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("A3-->"+atomicStampedReference.getStamp());

        },"A").start();
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("B1-->"+atomicStampedReference.getStamp());

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(10, 30, stamp, stamp + 1));

            System.out.println("B2-->"+atomicStampedReference.getStamp());
        },"B").start();
    }
}

各种锁的理解

公平锁、非公平锁

公平锁：非常公平，不能够插队，必须先来后到！

非公平锁：非常不公平，可以插队（默认是非公平锁）

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可重入锁

可重入锁（递归锁）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GcvsQ4vq-1659314192153)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659076161036.png)]

synchronized版

package com.example.juc.lock;

/**
 * @author swh
 * @date 2022/7/29 14:30
 */

//synchronized
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.example.juc.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author swh
 * @date 2022/7/29 14:30
 */

//synchronized
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();
    //lock锁必须配对，否则就会死在里面
    public  void sms() {
        lock.lock();//细节问题   lock.lock();  lock.unlock();
        try {
            System.out.println(Thread.currentThread().getName() + "-- -->" + "sms");
            call();//这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }



    }

    public  void call() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "-- -->" + "call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

自旋锁

spinlock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ea0QGrXO-1659314192154)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659072493357.png)]

自定义一个锁去测试：

package com.example.juc.lock;

/**
 * @author swh
 * @date 2022/7/29 14:53
 */

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLockDemo {

    //int  0
    //Thread null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"-->myLock");

        //自旋锁
        while (atomicReference.compareAndSet(null,thread)){

        }
    }


    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"-->myUnLock");

        atomicReference.compareAndSet(thread,null);
    }

}

测试

package com.example.juc.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author swh
 * @date 2022/7/29 15:12
 */

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();


        //底层使用的自旋锁CAS
        SpinLockDemo spinLock = new SpinLockDemo();

        new Thread(()->{
            spinLock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(2);

        new Thread(()->{
            spinLock.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLock.myUnLock();
            }
        },"T2").start();

    }
}

死锁

死锁是什么

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4OG7Jay3-1659314192155)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659079622797.png)]

package com.example.juc.lock;

import java.util.concurrent.TimeUnit;

/**
 * @author swh
 * @date 2022/7/29 15:27
 */

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();

//        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() + "lock:" + lockA + "-->get" + lockB);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "-->get" + lockA);
            }
        }
    }
}

解决问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55yfO5bm-1659314192156)(C:\Users\swh\AppData\Roaming\Typora\typora-user-images\1659082370090.png)]

1、使用jps -l定位进程

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

面试，工作中！排查问题：

1、日志

2、堆栈信息

ShanHai山海

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JUC进阶

java.util工具包，包，分类Runnable 没有返回值、效率相比于Callable相对比较低进程：一个程序（QQ.exe Music.exe）的集合一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程？ 2个 main、GC线程：开了一个oneNote，写字，自动保存（线程负责）对于Java而言：Thread、Runnable、Callable并发编程：并发、并行并发（多线程操作同一个资源）并行（多个人一起行走）并发编程的本质：充分利用CPU的资源1.来自不同的类wait
复制链接

扫一扫