JUC并发编程（终章）各种锁的理解

合集 - JUC并发编程(20)

1.JUC并发编程学习笔记（二）Lock锁(重点)2023-11-022.JUC并发编程学习笔记（一）认知进程和线程2023-11-023.JUC并发编程学习笔记（三）生产者和消费者问题2023-11-024.JUC并发编程学习笔记（四）8锁现象2023-11-025.JUC并发编程学习（五）集合类不安全2023-11-036.JUC并发编程学习笔记（六）Callable(简单)2023-11-037.JUC并发编程学习笔记（七）常用的辅助类2023-11-048.JUC并发编程学习笔记（八）读写锁2023-11-049.JUC并发编程学习笔记（九）阻塞队列2023-11-0410.JUC并发编程学习笔记（十）线程池（重点）2023-11-0411.JUC并发编程学习（十一）四大函数式接口（必备）2023-11-0512.JUC并发编程学习笔记（十二）Stream流式计算2023-11-0513.JUC并发编程学习（十三）ForkJoin2023-11-0614.JUC并发编程学习笔记（十四）异步回调2023-11-0615.JUC并发编程学习笔记（十五）JMM2023-11-0716.JUC并发编程学习笔记（十七）彻底玩转单例模式2023-11-0917.JUC并发编程学习笔记（十九）原子引用2023-11-14

18.JUC并发编程（终章）各种锁的理解2023-11-16

19.JUC并发编程学习笔记（十六）Volatile2023-11-0820.JUC并发编程学习笔记（十八）深入理解CAS2023-11-10

收起

各种锁的理解

公平锁、非公平锁

公平锁：先到先得（不可插队）

非公平锁：达者为先（可插队）---------->默认

public ReentrantLock() {
    //默认非公平锁
    sync = new NonfairSync();
}

//重载的构造方法，通过fair控制是否公平
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可重入锁（递归锁）

所有的锁都是可重入锁

Synchronized版

package org.example.lock;
 
 
public class Demo01 {
    public static void main(String[] args) {
        phone1 p1 = new phone1();
        new Thread(()->{
            p1.ems();
        },"A").start();
        new Thread(()->{
            p1.ems();
        },"B").start();
    }
}
class phone1{
    public synchronized void ems(){
        System.out.println(Thread.currentThread().getName()+"---------->ems");
        call();
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"---------->call");
    }
}

ems方法中包含了call方法，所以当我们调用ems方法获取到锁时，也把call方法的synchronized锁获取到了。

错误理论

• 当线程A运行ems方法后运行call方法时ems锁释放，线程B可以获取到ems方法

正确理论

• 当线程A运行ems方法后运行call方法时ems方法的锁还未释放时就拿到了call方法中的锁，当call方法的锁释放后ems方法的锁才会释放。线程B此时就可以运行ems方法了

Lock版

package org.example.lock;
 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Demo02 {
    public static void main(String[] args) {
        phone2 p2 = new phone2();
        new Thread(()->{
            p2.ems();
        },"A").start();
        new Thread(()->{
            p2.ems();
        },"B").start();
    }
}
class phone2{
    Lock lock = new ReentrantLock();
    public  void ems(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"---------->ems");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //等待call方法锁解锁后再解锁
            lock.unlock();
        }
 
    }
    public void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"---------->call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
 
    }
}

自旋锁

spinlock(不断尝试直至成功)

已经见过了，就是unsafe中的自增getAndAddInt方法中的do-while循环就是一把自旋锁

自己写一把锁

package org.example.lock;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
 
public class SpinLockDemo {
    //int 0
    //Thread null
    public static AtomicReference<Thread> atomic = new AtomicReference<>();
 
    public static void lock(){
        Thread thread = Thread.currentThread();
        System.out.println("===============>"+thread.getName()+"===========>lock");
        //自旋锁,若线程等于null，则compareAndSet为true，加！就为false，就会一直循环
        while (!atomic.compareAndSet(null,thread)){
 
        }
    }
    public static void unlock(){
        Thread thread = Thread.currentThread();
        System.out.println("===============>"+thread.getName()+"===========>unlock");
        //自旋锁
        atomic.compareAndSet(thread,null);
    }
 
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            try {
                lock();
                TimeUnit.SECONDS.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            try {
                lock();
                TimeUnit.SECONDS.sleep(2);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        },"B").start();
    }
}

死锁

死锁是什么

死锁测试

package org.example.lock;
 
import java.util.concurrent.TimeUnit;
 
public class DeadLockDemo {
    public static void main(String[] args) {
        String a = "A";
        String b = "B";
        new Thread(()->{new MyThread(a, b).run();},"A").start();
        new Thread(()->{new MyThread(b, a).run();},"B").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定位进程号

查看当前java活着的进程

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

查找到一个死锁问题！

面试或者工作中排查问题：

1、查看异常

2、查看日志

3、查看堆栈信息