14.ForkJoin
什么是ForkJoin
ForkJoin在JDK1.7,并行执行任务,提高效率,大数据量
大数据:Map Reduce(把大任务拆分为小任务)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QQCOCgpC-1626436829746)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626324475308.png)]
ForkJoin特点:工作窃取
这个里面维护的都是双端队列
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i4i19FDX-1626436829751)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626324591073.png)]
ForkJoin的操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2uEhsyU9-1626436829756)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626325361726.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WUKMn8JD-1626436829761)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626325556442.png)]
测试类
package com.ff.forkjoin;
import java.util.concurrent.RecursiveTask;
/**
* 求和计算
* ForkJoin Stream并行流
* 如何使用ForkJoin
* 1.forkjoinPool 通过它来执行
* 2.计算任务 forkjoinPool.execute(ForkJoinTask task)
* 3.计算类要继承ForkJoinTask
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start; //1
private Long end; //10000000000
//临界值
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();
}
}
}
测试:
package com.ff.forkjoin;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//test1();//11199
//test2();//9334
//test3();//745
}
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(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));
}
public static void test3(){
Long start = System.currentTimeMillis();
//Stream并行流range[) rangeClosed(] 并行
Long sum = LongStream.rangeClosed(0L,10_0000_0000L).parallel().reduce(0,Long::sum);
Long end = System.currentTimeMillis();
System.out.println("sum = "+sum+"时间:"+(end-start));
}
}
15.异步回调
Future设计的初衷:对将来的某个事件的结果进行建模
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mn9ksDS5-1626436829767)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626328076514.png)]
package com.ff.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* 异步调用:Ajax CompletableFuture
* 异步执行
* 成功回调
* 失败回调
*/
public class Demo01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//发起一个请求
//没有返回值的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("1111");
completableFuture.get();//获取阻塞执行结果*/
//有返回值的supplyAsync异步回调
//ajax,成功和失败的回调
//返回的是错误信息
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
int i = 10/0;
return 1024;
});
System.out.println(completableFuture.whenComplete((t, u) -> {
System.out.println("t=>" + t);//正常的返回结果
System.out.println("u=>" + u);//错误信息
}).exceptionally((e) -> {
e.getMessage();
return 233;//可以获取到错误的返回结果
}).get());
}
}
16.JMM
请你谈谈你对Volatile
Volatile是java虚拟机提供轻量级的同步机制
1.保证可见性
2.不保证原子性
3.禁止指令重排
什么是JMM
JMM: Java内存模型,不存在的东西,概念,约定
关于JMM的一些同步约定:
1.线程解锁前,必须把共享变量立刻刷回主存
2.线程加锁前,必须读取主存中的最新值到工作内存中
3.加锁和解锁是同一把锁
线程 工作内存、主内存
八种操作:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-miG0Pbpd-1626436829769)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626346292918.png)]
内存交互操作有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操作之前,必须把此变量同步回主内存
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ia7sohUL-1626436829771)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626346334433.png)]
问题:程序不知道主内存的值已经被修改过了
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cIGcFn2z-1626436829775)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626347064257.png)]
17.Volatile
1.保证可见性
package com.ff.tvolatile;
import java.util.concurrent.TimeUnit;
public class JMMDemo {
//不加Volatile程序就会死循环
//加 Volatile 可以保证可见性
private volatile static int num = 0;
public static void main(String[] args) throws InterruptedException {//main
new Thread(()->{
//线程1 对主内存的变化不知道
while (num == 0){
}
}).start();
TimeUnit.SECONDS.sleep(1);
num = 1;
System.out.println(num);
}
}
2.不保证原子性
原子性:不可分割
线程A在执行任务的时候,不能被打扰,也不能被分割。要么同时成功,要么同时失败。
package com.ff.tvolatile;
import java.util.concurrent.TimeUnit;
public class JMMDemo02 {
//不保证原子性
private volatile static int num = 0;
public static void add() {
num++;
}
public static void main(String[] args) {
//理论上num结果为20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j=0;j<1000;j++){
add();
}
}).start();
}
while (Thread.activeCount()>2){
//main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
如果不加lock和synchronized,怎么样保证原子性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KQHIwxmT-1626436829779)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626348085144.png)]
使用原子类,解决原子性问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R4bnNxlS-1626436829781)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626348416259.png)]
package com.ff.tvolatile;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class JMMDemo02 {
//不保证原子性
//原子类的Integer
private volatile static AtomicInteger num = new AtomicInteger();
public static void add() {
//num++;//不是一个原子性操作
num.getAndIncrement();//AtomicInteger +1方法,CAS
}
public static void main(String[] args) {
//理论上num结果为20000
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j=0;j<1000;j++){
add();
}
}).start();
}
while (Thread.activeCount()>2){
//main gc
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
这些类的底层都直接和操作系统挂钩,在内存中修改值。Unsafe类是一个很特殊的存在。
3.禁止指令重排
什么是指令重排:你写的程序,计算机并不是按照你写的那样去执行的。
源代码–>编译器优化的重排->指令并行也可能会重排->内存系统也会重排->执行
处理器在进行指令重排的时候,考虑:数据之间的依赖性!
int x = 1;//1
int y = 2;//2
x = x + 5;//3
y = x * x;//4
//我们所期望的顺序:1234 但是有可能会变成2134 1324
可能造成影响的结果:a b x y 这四个值默认都是0;
线程A | 线程B |
---|---|
x=a | y=b |
b=1 | a=2 |
正常的结果:x = 0;y = 0;但是可能由于指令重排
线程A | 线程B |
---|---|
b=1 | a=2 |
x=a | y=b |
指令重排导致的诡异结果:x=2;y=1;
volatile可以避免指令重排:
内存屏障。CPU指令。作用:
1.保证特定的操作的执行顺序
2.可以保证某些变量的内存可见性(利用这些特性volatile实现了可见性)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-glyNAxfH-1626436829783)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626351896798.png)]
volatile是可以保证可见性但是不能保证原子性,由于内存屏障,可以避免指令重排的现象产生。
18.单例模式
java中单例模式是一种常见的设计模式,单例模式的写法有好几种,主要有:懒汉式单例、饿汉式单例、登记式单例。
特点
1.单例类只能有一个实例;
2.单例类必须自己创建自己的唯一实例;
3.单例类必须给所有其他对象提供这一实例。
单例模式确保每个类只有一个实例,而且自行实例化并向整个系统提供这一实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计为单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态。
饿汉式 DCL懒汉式,深究
饿汉式
天生是线程安全的
package com.ff.single;
//饿汉式单例
public class Hungry {
//可能会浪费空间
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
DCL懒汉式
package com.ff.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
//懒汉式单例模式
public class Lazy {
private static boolean qinjiang = false;
private Lazy(){
synchronized (Lazy.class){
if (qinjiang == false){
qinjiang = true;
}else {
throw new RuntimeException("不要试图使用反射破坏异常");
}
/*if (lazy!=null){
throw new RuntimeException("不要试图使用反射破坏异常");
}*/
}
System.out.println(Thread.currentThread().getName()+" ok ");
}
private volatile static Lazy lazy;
//双重检测锁模式的懒汉式单例 DCL
public static Lazy getInstance(){
if (lazy == null){
synchronized(Lazy.class){
if (lazy == null){
lazy = new Lazy();//不是一个原子性操作
}
}
}
return lazy;
}
//反射
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
/*for (int i=0;i<10;i++){
new Thread(()->{
Lazy.getInstance();
}).start();
}*/
//Lazy instance = Lazy.getInstance();
Field qinjiang = Lazy.class.getDeclaredField("qinjiang");
qinjiang.setAccessible(true);
Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
Lazy instance1 = declaredConstructor.newInstance();
qinjiang.set(instance1,false);
Lazy instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
/**
* 1.分配内存空间
* 2.执行构造方法,初始化对象
* 3.把这个对象指向这个空间
*
*
* 123
* 132 A
* B //此时lazy还没有完成构造
*/
静态内部类
package com.ff.single;
//静态内部类实现
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.ff.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//enum(枚举) 是一个什么? 本身也是一个class类
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle instance2 = declaredConstructor.newInstance();
//NoSuchMethodException: com.ff.single.EnumSingle.<init>()
System.out.println(instance1);
System.out.println(instance2);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8q7fCNMB-1626436829790)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626358153432.png)]
枚举类型的最终反编译源码:
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: EnumSingle.java
package com.ff.single;
public final class EnumSingle extends Enum
{
public static EnumSingle[] values()
{
return (EnumSingle[])$VALUES.clone();
}
public static EnumSingle valueOf(String name)
{
return (EnumSingle)Enum.valueOf(com/ff/single/EnumSingle, name);
}
private EnumSingle(String s, int i)
{
super(s, i);
}
public EnumSingle getInstance()
{
return INSTANCE;
}
public static final EnumSingle INSTANCE;
private static final EnumSingle $VALUES[];
static
{
INSTANCE = new EnumSingle("INSTANCE", 0);
$VALUES = (new EnumSingle[] {
INSTANCE
});
}
}
饿汉式和懒汉式的区别
饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了。
而懒汉式就是只有当调用getInstance的时候,才会去初始化这个单例。
1.线程安全:
饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题;懒汉式本身是非线程安全的,为了实现线程安全有几种写法。
2.资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成;
而懒汉式会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
19.深入理解CAS
什么是CAS
package com.ff.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2021);
//期望 //更新
//public final boolean compareAndSet(int expect, int update)
//如果期望值达到了,就更新,否则不更新,CAS是CPU的并发原理
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
}
}
Unsafe类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HKFGh6d4-1626436829795)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626394916316.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ozyrcHp-1626436829797)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626413302240.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mYEeYJk0-1626436829800)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626413397260.png)]
CAS:比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么则执行操作,如果不是就一直循环。
缺点:
1.循环会耗时
2.一次性只能保证一个共享变量的原子性
3.ABA问题
CAS:ABA问题(狸猫换太子)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lABjnOnw-1626436829804)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626414015332.png)]
package com.ff.cas;
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2021);
//对于我们平时写的SQL:乐观锁
//期望 //更新
//public final boolean compareAndSet(int expect, int update)
//如果期望值达到了,就更新,否则不更新,CAS是CPU的并发原理
//==============捣乱的线程=============
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
//==============期望的线程=============
System.out.println(atomicInteger.compareAndSet(2021, 6666));
System.out.println(atomicInteger.get());
}
}
20.原子引用
解决ABA问题,引入原子引用。对应的思想:乐观锁
带版本号的原子操作
package com.ff.cas;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
//CAS compareAndSet 比较并交换
public static void main(String[] args) {
//AtomicInteger atomicInteger = new AtomicInteger(2021);
//atomicInteger如果泛型是一个包装类,注意对象的引用问题
//正常在业务操作,这里面比较的都是一个对象
AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(12,1);
new Thread(()->{
int stamp = atomicInteger.getStamp();//获得版本号
System.out.println("A1=>"+atomicInteger.getStamp());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(12,
13,
atomicInteger.getStamp(),
atomicInteger.getStamp() + 1));
System.out.println("A2=>"+atomicInteger.getStamp());
System.out.println(atomicInteger.compareAndSet(13,
12,
atomicInteger.getStamp(),
atomicInteger.getStamp() + 1));
System.out.println("A3=>"+atomicInteger.getStamp());
},"A").start();
//乐观锁的原理相同
new Thread(()->{
int stamp = atomicInteger.getStamp();//获得版本号
System.out.println("B1=>"+atomicInteger.getStamp());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicInteger.compareAndSet(12,
14,
atomicInteger.getStamp(),
atomicInteger.getStamp() + 1));
System.out.println("B2=>"+atomicInteger.getStamp());
},"B").start();
}
}
注意:
Integer使用了对象缓存机制,默认范围是-128~127,推荐使用静态工厂方法valueOf获取对象实例,而不是new,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3rToj0zb-1626436829808)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626416420945.png)]
21.各种锁的理解
1.公平锁、非公平锁
公平锁:非常公平,不能够插队,必须先来后到
非公平锁:非常不公平,可以插队(默认都是非公平)
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
2.可重入锁
可重入锁(递归锁)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tcwIuvWf-1626436829810)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626432326711.png)]
Synchronized版
package com.ff.lock;
//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.ff.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//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();
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();
}
}
}
3.自旋锁
spinlock
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OLHUg5Tf-1626436829814)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626433068070.png)]
自定义锁测试
package com.ff.lock;
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.getName() + "==> myLock");
//自旋锁
while (!atomicReference.compareAndSet(null,thread)){
}
}
//解锁
public void myUnLock(){
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + "==> myUnLock");
atomicReference.compareAndSet(thread,null);
}
}
package com.ff.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TestSpinlock {
public static void main(String[] args) throws InterruptedException {
/*ReentrantLock reentrantLock = new ReentrantLock();
reentrantLock.lock();
reentrantLock.unlock();*/
//底层使用的自旋锁CAS
SpinlockDemo lock = new SpinlockDemo();
new Thread(()->{
lock.myLock();
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
},"T1").start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
lock.myLock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.myUnLock();
}
},"T2").start();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K62z31tF-1626436829817)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626434310616.png)]
4.死锁
死锁的四大必要条件
1.互斥:某种资源一次只允许一个进程访问,即该资源一旦分配给某个进程,其它进程就不能再访问,直到该进程访问结束;
2.占有且等待:一个进程本身占有资源(一种或多种),同时还有资源未得到满足,正在等待其它进程释放该资源;
3.不可抢占:别人已经占有了某项资源,你不能因为自己也需要该资源,就把别人的资源抢过来;
4.循环等待:存在一个进程链,使得每个进程都占有下一个进程所需的至少一种资源。
死锁是什么
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ckst18v-1626436829826)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626434457068.png)]
死锁测试,怎么排除死锁
package com.ff.lock;
import java.util.concurrent.TimeUnit;
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new MyThread(lockA,lockB),"T1").start();
new Thread(new MyThread(lockB,lockA),"T2").start();
}
}
class MyThread implements Runnable{
private String lockA;
private String lockB;
public MyThread(String lockA,String lockB){
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA){
System.out.println(Thread.currentThread().getName()+
" lock:"+lockA+"=>get"+lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+
" lock:"+lockB+"=>get"+lockA);
}
}
}
}
解决问题
1.使用jps -l定位进程号
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fQOS4t3Y-1626436829828)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626436074260.png)]
2.使用jstack 进程号找到死锁问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8PZkiST-1626436829830)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1626436352707.png)]
面试或者工作中,排查问题:
1.日志
2.堆栈信息
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) {
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+
" lock:"+lockB+"=>get"+lockA);
}
}
}
}
> 解决问题
1.使用==jps -l==定位进程号
[外链图片转存中...(img-fQOS4t3Y-1626436829828)]
2.使用==jstack 进程号==找到死锁问题
[外链图片转存中...(img-X8PZkiST-1626436829830)]
面试或者工作中,排查问题:
1.日志
2.堆栈信息