四大函数试接口

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

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

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

代码测试：

函数式接口：funcation

import java.util.function.Function;

/**
 *  Function 函数类型接口，有一个输入参数，有一个输出
 *  只要是 函数类型接口 可以 用 lambda 表达式简化
 */
public class FunctionTest {
    public static void main(String[] args) {
       /* Function<String,String> function = new Function<String,String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };*/
        Function<String,String> function = (str)->{return str;};
        System.out.println(function.apply("aaa"));
    }
}

断定型接口：Predicate

import java.util.function.Predicate;

/**
 *  断定型接口: 有一个输入参数，返回值只能是 布尔值！
 */
public class PredicateTest {
    public static void main(String[] args) {
        Predicate<String> predicate = new Predicate<String>() {
            //判断字符串是否为空
            @Override
            public boolean test(String str) {
                return str.isEmpty();
            }
        };
        // lambda表达式简化版
        Predicate<String> predicate1 = str->{return str.isEmpty(); };
        System.out.println(predicate.test(""));
        System.out.println(predicate1.test("11"));
    }
}

Consumer 消费型接口

import java.util.function.Consumer;

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

Supplier 供给型接口

import java.util.function.Supplier;

/**
 * Supplier 供给型接口 没有参数，只有返回值
 */
public class SupplierTest {
    public static void main(String[] args) {
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("get()");
                return "1111";
            }
        };
        Supplier<String> supplier1 = () -> {
            return "2222";
        };
        System.out.println(supplier.get());
        System.out.println(supplier1.get());
    }
}

 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) {
        Users u1 = new Users(1, "a", 21);
        Users u2 = new Users(2, "b", 22);
        Users u3 = new Users(3, "c", 23);
        Users u4 = new Users(4, "d", 24);
        Users u5 = new Users(6, "e", 25);
        // 集合就是存储
        List<Users> list = Arrays.asList(u1, u2, u3, u4, u5);

        //  计算交给Stream流
        list.stream().filter(u -> {
                    return u.getId() % 2 == 0;
                }).filter(u -> {
                    return u.getAge() > 23;
                }).map(u -> {
                    return u.getName().toUpperCase();
                })
                .sorted((id1, id2) -> {
                    return id2.compareTo(id1);
                }).limit(1)
                .forEach(System.out::println);
    }
}

ForkJoin

ForkJoin在1.7，并行执行任务!提高效率，大数据量

大数据： Map Reduce（把大人物拆分为小任务）

ForkJoin 特点：工作窃取

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

 

 

 ForkJoinDemo：

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算的任务
 * 30006000 (ForkJoin)900e (Stream并行流>//如何使用forkjoin
 * 1、forkJoinPooL通过它来执行
 * 计算任务forkJoinPooL.execute( ForkJoinTask task )
 * 计算类 要继承 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) < temp) {
            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();
        }
    }
}

test：

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(); 5670
        // test2(); 4103
        //test3();  155
    }

    // 最普通的方法
    private static void test1() {
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum:=>" + sum + "时间:=>" + (end - start));
    }

    // 进阶版 ForkJoin
    private 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 sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum:=>" + sum + "时间:=>" + (end - start));
    }

    // 进阶版 Stream 并行流
    private static void test3() {
        long start = System.currentTimeMillis();

        // Stream 并行流
        long sum = LongStream
                .rangeClosed(0L, 10_0000_0000L)
                .parallel()
                .reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum:=>" + sum + "时间:=>" + (end - start));
    }

异步回调

 代码：

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

/**
 * 异步回调: CompletableFuture
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class FutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test2();
    }

    private static void test2() throws ExecutionException, InterruptedException {
        // 发起一个请求 有返回值的 runAsync 异步回调
        // Ajax,成功和失败的回调
        // 返回的是错误信息
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            int i = 10 / 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) -> {
            // 失败回调
            System.out.println(e.getMessage());
            return 404; // 可以获取到错误的返回结果
        }).get());
    }

    private static void test1() throws InterruptedException, ExecutionException {
        // 发起一个请求 没有返回值的 runAsync 异步回调
        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(); // 获取阻塞执行结果
    }
}

JMM

volatile 是JAVA 虚拟机提供轻量级的同步机制

1.保证可见性

2.不保证原子性

3.禁止指令重排

什么是JMM

JMM：JAVA内存模型，不存在的东西，概念，约定

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

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

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

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

线程 工作内存，主内存

8种操作

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

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

　　JMM对这八种指令的使用，制定了如下规则：

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

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

Volatile

1.保证可见性

import java.util.concurrent.TimeUnit;

public class JMMTest {
    // 不加 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在执行任务的时候，不能被打扰的，也不能被分割，要么同时成功，要么同时失败

// 不保证原子性
public class VolatileTest {
    // volatile 不保证原子性
    private volatile static int num = 0;
    public static void main(String[] args) {

        // 理论上num结果应该为 2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){
            // java 默认有两个线程在执行 分别为 main线程 和gc线程
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "  " + num);
    }

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

}

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

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

import java.util.concurrent.atomic.AtomicInteger;

// 不保证原子性
public class VolatileTest {
    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void main(String[] args) {

        // 理论上num结果应该为 2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){
            // java 默认有两个线程在执行 分别为 main线程 和gc线程
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "  " + num);
    }

    public static void add() {
        num.getAndIncrement();// AtomicInteger + 1 方法，CAS
    }

}

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

 指令重排

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

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

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

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
// 我们所期望的是：1234按照顺序执行， 但是可能执行的时候会变成 2134 1324

可能造成的结果：

a、b、c、d这四个值默认都是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 是可以保持 可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生

单例模式

饿汉式：

// 饿汉式单例
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懒汉式：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

// 懒汉式单例模式
public class LazyMan {
    private static boolean li = false;

    private LazyMan() {
        synchronized (LazyMan.class) {
            if (li == false) {
                li = true;
            } else {
                throw new RuntimeException("不要试图通过反射破坏程序");
            }
            /*if (lazyMan != null) {

                //System.out.println("不要试图通过反射破坏程序");
            }*/
        }
    }

    private volatile static LazyMan lazyMan;

    // 双重检测锁模式的 懒汉式单例 DCL 懒汉式
    private static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan(); // 这不是一个原子性的操作
                    /**他会先
                     *  1.分配内存空间
                     *  2.执行构造方法，初始化对象
                     *  3.把这个对象指向这个空间
                     *  我们期望的执行顺序为： 1、2、3
                     *  而可能执行的是 1、3、2  如果同时有两个线程 A执行 1、3
                     *                                      B 此时 LazyMan还没有完成构造
                     *
                     */
                }
            }
        }

        return lazyMan;
    }

    // 多线程并发
    public static void main(String[] args) throws Exception {
      /*  for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
            }*/

        // 反射可以破坏这种懒汉单例模式

        Field li = LazyMan.class.getDeclaredField("li");
        li.setAccessible(true);
        Constructor<LazyMan> declaredConstructor =
                LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true); // 无视私有构造器
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        li.set(lazyMan1, false);
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan1);
        System.out.println(lazyMan2);
        System.out.println(lazyMan1 == lazyMan2);

    }
}

静态内部类：

// 静态内部类
public class Holder {
    private Holder() {

    }

    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }
}

 单例不安全；反射

枚举

import java.lang.reflect.Constructor;

/**
 * enum 是什么？
 * 本身也是一个Class类
 */
public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }

}

class test {
    public static void main(String[] args) throws NoSuchMethodException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = EnumSingle.INSTANCE;

        //NoSuchMethodException: com.li.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);
    }

}

CAS 

什么是CAS

Unsafe类

 

import java.util.concurrent.atomic.AtomicInteger;

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

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

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

缺点：
1.循环会耗时

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

3.ABA问题

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

有两条线程A、B 在A执行之前 B把值发生了修改但A不知道这个值已经被改变

import java.util.concurrent.atomic.AtomicInteger;

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

        // 期望、更新
        //  public final boolean compareAndSet(int expect, int update)
        // 如果我们期望的值达到了，那么就更新，否则，就不更新 CAS 是CPU的并发原语
        //  ======================= 捣乱的线程 ================
        System.out.println(atomicInteger.compareAndSet(2022, 2023));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2023, 2022));
        System.out.println(atomicInteger.get());
        //  ======================= 期望的线程 ================
        System.out.println(atomicInteger.compareAndSet(2022, 1111));
        System.out.println(atomicInteger.get());
    }
}

原子引用：

 带版本号的原子操作

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

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

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

public class CASDemo {
    public static void main(String[] args) {
        //  AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);
        // 乐观锁原理相同
        new Thread(() -> {
            int stamp = atomicInteger.getStamp(); // 获得版本号
            System.out.println("A1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(1, 2,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1);
            System.out.println("A2=>" + atomicInteger.getStamp());

            atomicInteger.compareAndSet(2, 1,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1);
            System.out.println("A2=>" + atomicInteger.getStamp());
        }, "A").start();


        new Thread(() -> {
            int stamp = atomicInteger.getStamp(); // 获得版本号
            System.out.println("B1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(1, 3333,
                    stamp, stamp + 1);
            System.out.println("B1=>" + atomicInteger.getStamp());
        }, "B").start();
    }
}

 各种锁的理解·

公平锁、非公平锁

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

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

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

可重入锁

可重入锁（递归锁）

 synchronized

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

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

// Lock
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 锁必须配对 否则就会死在里面
        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();
        }
    }
}

 

自旋锁

自定义锁测试

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinlockTest {
    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);
    }
}

测试：

import java.util.concurrent.TimeUnit;

public class TestSpinlock {
    public static void main(String[] args) throws InterruptedException {
        // 底层使用的自旋锁CAS
        SpinlockTest lock = new SpinlockTest();
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();
    }
}

死锁

死锁是什么 

死锁测试，怎么排除死锁

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() + "lock:" + lockA + "=>" + lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "=>" + lockA);
            }
        }
    }
}

 解决问题：

1.使用jps -l 定位进程号

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

推荐视频：【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩_bilibili