JUC —— 各种锁的理解

公平锁、非公平锁

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

可重入锁

可重入锁（递归锁）
拿到了最外层的锁，就自动获得了里面的锁

public class 可重入锁 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.call();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}
class Phone{
    public synchronized void call(){
    	//执行的call，但call里面包含了sms，所以获取call锁后会自动获取sms的锁
        System.out.println(Thread.currentThread().getName()+"打电话");
        sms();
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
}

执行结果：

A打电话
A发短信
B发短信

自旋锁

public class Spinlock {
    AtomicReference<Thread> atomicReference = new AtomicReference();

    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"加锁");
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void unlock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"解锁");
        atomicReference.compareAndSet(thread,null);
    }

    public static void main(String[] args) throws InterruptedException {
        Spinlock spinlock = new Spinlock();

        new Thread(()->{
            spinlock.lock();
            try{
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinlock.unlock();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            spinlock.lock();
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinlock.unlock();
            }
        },"B").start();
    }
}

执行结果：

A加锁
B加锁
A解锁
B解锁

死锁

产生死锁的四个必要条件：

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

只要破坏其中的任意一个或多个条件就可以避免死锁

死锁测试、怎么排除死锁：

public class Demo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"a").start();
        new Thread(new MyThread(lockB,lockA),"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()+"获取lockA"+lockA+"，想要获取lockB"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lockB"+lockB+"，想要获取lockA"+lockA);
            }
        }
    }
}

解决问题：
jdk bin目录下有一些工具：
1.使用jps -l定位进程号

2.使用jstack 进程号，查看进程信息，找到死锁问题

工作中排查问题：

• 日志
• 堆栈