文章目录

• JUC并发编程—— 各种锁的理解
• • 1、公平锁，非公平锁
  • 2、可重入锁
  • 3、自旋锁
  • 4、死锁

JUC并发编程—— 各种锁的理解

1、公平锁，非公平锁

公平锁是指当锁可用时,在锁上等待时间最长的线程将获得锁的使用权，必须先来后到。

//ReentrantLock(true)设置为公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

非公平锁则随机分配这种使用权，可以插队。有时候，一些线程的执行时间很长，如果其他线程需要锁的话就需要等待很长的时间，所以为了提供效率，我们一般使用非公平锁

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

2、可重入锁

可重入锁又叫递归锁，指同一个线程在外层方法获取锁的时候，进入内层方法会自动获取锁。JDK 中基本都是可重入锁，避免死锁的发生。

synchronized 可重入锁

public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").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 可重入锁

public class Demo02 {

    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sms();
        },"A").start();
}
class Phone2{

    Lock lock=new ReentrantLock();

    public void sms(){
        lock.lock(); //细节：这个是两把锁，分别是sms和call
        //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）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。尝试获取锁的线程不会立即阻塞，采用循环的方式尝试获取锁！减少上下文的切换！缺点会消耗CPU

自定义自旋锁

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

测试自旋锁

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        
        SpinLockDemo lockDemo = new SpinLockDemo();
        new Thread(()->{
            lockDemo.myLock();
            try{
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lockDemo.myUnlock();
            }

        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

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

线程T1先拿到锁，T2在自旋等待，直到T1释放了锁，T2才结束自旋，获取到锁。

4、死锁

死锁问题：多个线程互相拿着对方需要的资源，然后形成僵持。出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

产生死锁的四个必要条件

• 互斥条件：一个资源每次只能宝贝一个进程使用
• 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
• 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

死锁案例

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

            }
        }
    }
}

运行结果：

线程T1已经占有了A锁，在等待B锁，线程T2已经占有了B锁，在等待A锁，两个线程互相僵持，导致程序运行阻塞。

如何排查死锁

使用 进行排查，

jps(Java Virtual Machine Process Status Tool)是 jdk 提供的一个查看当前java进程的小工具。

以上面死锁为例，进行排查：

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

2、使用jstack + 进程号查看堆栈信息，用以分析线程情况