Java进阶—JUC编程（二）

最新推荐文章于 2023-06-27 12:00:22 发布
最新推荐文章于 2023-06-27 12:00:22 发布
阅读量490 收藏
点赞数
分类专栏： 视频笔记 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51929833/article/details/128418981
版权

11、四大函数式接口

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

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
// foreach(消费者的函数式接口)

测试函数式(Function)接口：

image-20221221220850710

import java.util.function.Function;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/21
 * @description
 * <p>
 *     Function 函数型接口,有一个参数，一个返回类型
 * </p>
 */
public class Demo01 {
    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("abc"));
    }
}

测试断定型(Predicate)接口：

image-20221221220107324

import java.util.function.Predicate;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/21
 * @description 断定型接口: 有一个参数输入，返回值只能是 布尔值！
 */
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 = String::isEmpty;
        System.out.println(predicate.test(""));
    }
}

Consumer 消费性接口

image-20221221221434328

import java.util.function.Consumer;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/21
 * @description 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("asd");
    }
}

Supplier 供给型接口

image-20221221222011616

import java.util.function.Supplier;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/21
 * @description 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());

    }
}

12、Stream流式计算

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 * <p>
 *     要求：现在有五个用户！筛选
 *     1、ID必须是偶数
 *     2、年龄必须大于23岁
 *     3、用户名转为大写字母
 *     4、用户名字母倒着排序
 *     5、只输出一个用户
 * </p>
 */
public class Test {
    public static void main(String[] args) {
        User user1 = new User(1, "a", 21);
        User user2 = new User(2, "b", 22);
        User user3 = new User(3, "c", 23);
        User user4 = new User(4, "d", 24);
        User user5 = new User(6, "e", 25);
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);

        // 链式编程
        list.stream()
                .filter(u -> {return u.getId() % 2 == 0;})
                .filter(user -> {return user.getAge() > 23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((u1, u2) -> {return u2.compareTo(u1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

13、ForkJoin

什么是ForkJoin

**ForkJoin：**在并行执行任务！提高效率，大数据量！把大任务拆成小任务

ForkJoin的特点：工作窃取

当本线程的任务执行完毕之后，回去找一部分其他线程未执行的任务去执行

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

ForkJoin的操作

import java.util.concurrent.RecursiveTask;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description ForkJoin测试
 * <p>
 *     // 1、forkJoin 通过它来执行
 *     // 2、计算任务 forkJoinPool.execute(ForkJoinTask task)
 *     // ForkJoinTask
 * </p>
 */
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;
    }

    /**
     * The main computation performed by this task.
     *
     * @return the result of the computation
     */
    @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 mid = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, mid);
            // 拆分任务
            task1.fork();
            ForkJoinDemo task2 = new ForkJoinDemo(mid + 1, end);
            task2.fork();

            return task1.join() + task2.join();
        }
    }
}

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // test1();     // 676
        // test2();     // 8909
        test3();        // 289
    }

    //
    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));
    }

    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(1L, 10_0000_0000L);
        // 执行任务
        // forkJoinPool.execute(task);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum = " + sum + "时间：" +(end - start));
    }

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

14、异步回调

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 * <p>
 *     异步调用： CompletableFuture, 异步执行：成功回调、失败回调
 * </p>
 */
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) {
//                throw new RuntimeException(e);
//            }
//            System.out.println(Thread.currentThread().getName() + "runAsync => Void");
//        });
//        System.out.println("1111");
//        completableFuture.get();

        // 有返回值的  supplyAsync 异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "supplyAsync => Integer");
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t = " + t); // 正常的结果返回
            System.out.println("u = " + u); // 错误信息：打印错误信息
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233;
        }).get());
    }
}

15、JMM

请你谈谈你对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：Java内存模型，不存在的东西

关于JMM的一些同步约定：

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

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

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

image-20221222205042908

Java内存模型定义了以下八种操作来完成：

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

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

  • 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
  • 不允许read和load、store和write操作之一单独出现
  • 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
  • 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
  • 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
  • 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
  • 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
  • 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
  • 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

16、Volatile

1、保证可见性

import java.util.concurrent.TimeUnit;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 */
public class JMMDemo {
    /**
     * 不加 volatile 程序会进入死循环
     * 家加 volatile 可以保证可见性
     */
    private volatile static int num = 0;
    public static void main(String[] args) {

        new Thread(() -> {
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num = 1;
        System.out.println(num);
    }
}

2、不保证原子性

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 * <p>
 *     不保证原子性
 * </p>
 */
public class VDemo02 {

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

    public static void add() {
        num++;
    }
    public static void main(String[] args) {

        new Thread(() -> {
            for (int i = 1; i <= 200; i++) {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }
        }).start();

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

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

使用原子类：解决原子性问题。

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试
 * <p>
 *     不保证原子性
 * </p>
 */
public class VDemo02 {

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

    public static void add() {
//        num++;
        num.getAndIncrement(); // AtomicInteger 加一操作
    }
    public static void main(String[] args) {

        new Thread(() -> {
            for (int i = 1; i <= 200; i++) {
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }
        }).start();

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

指令重排

什么是指令重排：源代码 ——> 编译器优化重排 ——> 指令并行也可能会重排 ——> 内存系统也会重排 ——> 执行

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

image-20221222212907700

volatile可以避免指令重排：

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

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

2、可以保证某些变量的内存可见性

image-20221222213233201

17、彻底玩转单例模式

饿汉式

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 饿汉式单例
 * <p>
 *     创建即私有
 * </p>
 */
public class Hungry {

    // 可能会造成空间浪费
    byte[] data1 = new byte[1024 * 1024];
    byte[] data2 = new byte[1024 * 1024];
    byte[] data3 = new byte[1024 * 1024];
    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;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 懒汉式单例
 */
public class LazyMan {

    private static boolean chen = false;
    private LazyMan() {
        synchronized (LazyMan.class){
            if (chen == false) {
                chen = true;
            } else {
                throw new RuntimeException("不要试图用反射破坏异常");
            }
            /*if (lazyMan != null) {
                throw new RuntimeException("不要试图用反射破坏异常");
            }*/
        }
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance() {
        // 加锁，双重检测锁模式的 懒汉模式 DCL模式
        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 chen1 = LazyMan.class.getDeclaredField("chen");
        chen1.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(String。class, int.class);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();

        chen1.set(instance, false);
        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);

    }
}

// 1、分配内存空间
// 2、执行构造方法，初始化对象
// 3、把这个对象指向这个空间

静态内部类

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 静态内部类
 */
public class Holder {
    
    private Holder() {
        
    }
    
    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }
    
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

单例不安全，反射：使用枚举

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 枚举单例
 */
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

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

        EnumSingle instance1 = EnumSingle.INSTANCE;

    }
}

18、深入理解CAS

什么是CAS

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description CAS测试
 */
public class CASDemo {

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

        // public final boolean compareAndSet(int expect, int update) 期望、更新
        // 如果我期望的值拿到了就更新，否则就不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

image-20221222222946800

image-20221222223513050

image-20221222223554731

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

缺点：

1、循环会耗时

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

3、ABA问题

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

image-20221222224130455

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description CAS测试
 */
public class CASDemo {

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

        // public final boolean compareAndSet(int expect, int update) 期望、更新
        // 如果我期望的值拿到了就更新，否则就不更新
        // ============= 捣乱的线程 ==============
        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());
    }
}

19、原子引用

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

带版本号的 原子操作！

import java.util.Date;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description CAS测试
 */
public class CASDemo {

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

        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(123,1);


        // public final boolean compareAndSet(int expect, int update) 期望、更新
        // 如果我期望的值拿到了就更新，否则就不更新
        // ============= 捣乱的线程 ==============
        /*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());*/

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

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println(atomicStampedReference.compareAndSet(123, 124,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2 => " + atomicStampedReference.getStamp());

            System.out.println(atomicStampedReference.compareAndSet(124, 123,
                    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(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println(atomicStampedReference.compareAndSet(123, 125,
                    stamp, stamp + 1));

        }, "B").start();

    }
}

20、各种锁的理解

1、可重入锁

Synchronized

package com.chen.lock;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 可重入锁
 * Synchronized
 */
public class Demo1 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone1.sms();
        }, "A").start();

        new Thread(() -> {
            phone1.sms();
        }, "B").start();

    }
}
class Phone {

    public synchronized void sms() {
        System.out.println(Thread.currentThread().getName() + "sms()");
        // call也有锁
        call();
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call()");
    }
}

lock

package com.chen.lock;

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 可重入锁Lock版
 */
public class Demo2 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();

        new Thread(() -> {
            phone1.sms();
        }, "A").start();

        new Thread(() -> {
            phone1.sms();
        }, "B").start();

    }
}
class Phone1 {

    Lock lock = new ReentrantLock();

    public void sms() {
        // 获得锁
        lock.lock(); // 细节：lock锁必须配对，否则就会产生死锁
        try {
            System.out.println(Thread.currentThread().getName() + "sms()");
            // call也有锁
            call();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

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

2、自旋锁

spinlock:

image-20221222232726646

自定义自旋锁测试：

package com.chen.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 自旋锁
 */
public class SpinLockDemo {

    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.chen.lock;

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 测试自旋锁
 */
public class TestSpinLock {
    public static void main(String[] args) {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();
        // 底层使用自旋锁
        SpinLockDemo lock = new SpinLockDemo();

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

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();
    }
}

3、死锁

死锁是什么？

image-20221222234258178

死锁测试

package com.chen.lock;

import java.util.concurrent.TimeUnit;

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/22
 * @description 死锁测试
 */
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 + "=> get" + lockB);

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

        }
    }
}

解决问题

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

image-20221222235536200

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

image-20221222235651187

java小豪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java并发编程：juc线程池
08-09
而了解 Java 并发编程以及其中的 JUC（java.util.concurrent）线程池，对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...
初始GUC（一）
Big Data
03-28 1589
1、什么时JUC JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包。 2、什么是进程与线程 进程：进程是程序的一次执行，进程是一个程序及其数据在处理机上顺序执行时所发生的活动，进程是具有独立功能的程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。 简单来说：一个进程包含多个线程，至少包含一个。 线程：线程作为资源调度的基本单位，是程序的执行单元，执行路径(单线程：一条执行路径，多线程：多条执行路径)。是程序使用CPU的最基本单
线程学习java
qq_43527345的博客
07-31 117
静态代理 继承接口，使用代理 真实对象和代理对象实现同一个接口 代理对象代理真实角色 好处：代理对象可以做很多真实对象做不了的事情 线程方法 设置线程优先级setPriority join 等待线程终止 yied 暂停当前正在执行的线程对象，执行其他的线程，线程礼让不一定成功 interrupt 终端线程不用 isAlive 测试线程是否处于活动状态 推荐线程自己停下来 使用一个标志位。设置一个标志位，设置一个公开的方法停止线程转换标志位 不要使用top或destroy或JDK不推荐使用的方法 sl
Java基础之线程学习
Trapped_beast的博客
08-04 341
1. 线程的实现方法 1.1 继承Thread类
Java关键字volatile知识点总结
dcj19980805的博客
03-31 410
在本篇文章里小编给大家整理的是一篇关于Java关键字volatile知识点总结内容，有兴趣的朋友们可以学习参考下。 volatile是什么 volatile关键字是Java提供的一种轻量级同步机制。它能够保证可见性和有序性，但是不能保证原子性 可见性 对于volatile的可见性，先看看这段代码的执行 flag默认为true 创建一个线程A去判断flag是否为true，如果为true循环执行i++操作两秒后，创建另一个线程B将flag修改为false 线程A没有感知到flag已经被修改成false了，不能
Java基础-并发篇
稷下
05-12 4213
3.1. JAVA 并发知识库 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x8MLzghL-1652349583715)(…/images/31.png)] 3.2. JAVA 线程实现/创建方式 3.2.1. 继承 Thread 类 ​ Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方 法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线 程，并执行
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
最新发布
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
Java-JUC-多线程 进阶
07-05
来自B站 遇见狂神说
Java并发编程JUC知识点梳理总结
06-01
JUC并发编程知识点梳理思维导图
java编发编程：JUC综合讲解
08-09
Java 并发编程在现代软件开发中占据重要地位，尤其是在多核处理器的时代。JUC（java.util.concurrent）库是 Java 标准库的一部分，提供了丰富的多线程并发工具，旨在帮助开发者编写高性能、高可伸缩性的并发程序。...
volatile关键字 java_解析Java的volatile关键字
weixin_29442503的博客
02-12 150
众所周知，无限制下多线程操作共享变量是危险的，为了保证线程安全语义，一般的建议是在操作共享变量时加锁，比方说在用synchronized关键字修饰的方法内读写共享变量。但是synchronized开销较大，有没有更轻量更优雅的解决方案呢？volatile是轻量级的synchronized，在正确使用的前提下，它可以达到与synchronized一样的线程安全的语义，而且不会带来线程切换的开销。vo...
JAVA中的并发知识介绍
Ahjbvj的博客
06-05 1439
第一种创建方式是通过直接集成Thread类，重写run方法进行创建线程。具体的如下图所示：我们使用自己定义的线程类可以创建3个线程，观察线程共享资源时出现的并发问题（多线性并发问题的解决，我们将在下面的篇幅进行讨论）如下图所示：创建线程的第二种方式是通过实现java.lang.Runnable接口实现线程，具体的创建过程如下所示：线程池就是管理一系列线程的资源池，提供了限制和管理线程资源的方式，它可以降低资源消耗，提高响应速度，提高线程的可管理性。
Java 并发（多线程）超详细
qq_42689380的博客
06-27 6049
超级详细解析了 Java 多线程的应用等
Java - JUC详解
S mile0804的博客
04-02 5015
一、概述 1.1 什么是JUC？ JUC是java.util.concurrent包的简称，在Java5.0添加，目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！ 1.2 什么是进程？ 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。在指令运行过程中还要用到磁盘、网络等设备。进程就是用来加载指令，管理内存管理IO的。 当一个进程被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为一个实例。
Java并发图文详解
qq_43842093的博客
02-18 1487
要说线程，必须得先说说进程。进程：进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。线程：线程是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。操作系统在分配资源时是把资源分配给进程的， 但是 CPU 资源比较特殊，它是被分配到线程的，因为真正要占用CPU运行的是线程，所以也说线程是 CPU分配的基本单位。比如在Java中，当我们启动 main 函数其实就启动了一个JVM进程，而 main 函数在的线程就是这个进程中的一个线程，也称主线程。
java并发总结
热门推荐
liujiqing123的博客
10-11 1万+
一、并发基础 ㅤ 1、进程与线程 ㅤ 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 一个进程之内可以分为一到多个
Java并发简介（什么是并发）
Lifelong learning
03-02 4934
进程、线程、安全性、活跃性、性能、死锁、饥饿、上下文切换
Java并发基础知识
故不积跬步无以至千里
09-16 583
安全的中止则是其他线程通过调用某个线程A的interrupt()方法对其进行中断操作，中断好比其他线程对该线程打了个招呼，“A，你要中断了”，不代表线程A会立即停止自己的工作，同样的A线程完全可以不理会这种中断请求。因为java里的线程是协作式的，不是抢占式的。在 Java 线程中，通过一个整型成员变量 priority 来控制优先级，优先级的范围从 1~10，在线程构建的时候可以通过 setPriority(int)方法来修改优先级，默认优先级是 5，优先级高的线程分配时间片的数量要多于优先级低的线程。
深入JVM--Java内存模型
张姐姐聊编程
08-30 269
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。
java的juc编程
09-29
JUC是指Java并发编程中的java.util.concurrent包，它提供了一系列新的关于并发操作的类，可以极大地方便我们实现并发编程。Java并发编程是基于多线程技术的一种编程技术，旨在解决资源利用率、响应速度和线程安全等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java小豪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值