13-各种锁的理解

23.各种锁的理解：公平锁、非公平锁、可重入锁、自旋锁、死锁

公平锁 :非常公平 ，线程先来后到

非公平锁 ：非常不公平，可以插队（默认是非公平的）

 public ReentrantLock() {
        sync = new NonfairSync();
    }


public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可重入锁

可重入锁(递归锁)

synchronized 版

package lock;

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

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

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();
        new Thread(()->{
            phone2.sms();
        },"A").start();
        new Thread(()->{
            phone2.sms();
        },"B").start();
    }
}
class Phone2{
   Lock lock= new ReentrantLock(); //细节问题 ： 两把锁 它也可以拿到call的锁
    public  void sms(){
        //lock锁必须配对，否则就会死在里面
       // lock.lock();//再锁的话 要再解锁一次！
    lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"---"+"sms");
            call();//这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            //lock.unlock();
        }
    }
    public  void call(){
       lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"---"+"call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

自旋锁

• 底层使用的自旋锁CAS

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

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

public class Test {
    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();

    }
}

死锁排查

死锁测试

package lock;

import java.rmi.server.ExportException;
import java.sql.Time;
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),"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()+"lock "+lockA+"尝试获得"+lockB);
            try{
                TimeUnit.SECONDS.sleep(2);
            }catch (Exception e){
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock "+lockB+"尝试获得"+lockA);

            }
        }

    }


}

怎么排除死锁

Terminal

使用jps -l定位进程号

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

排查问题

1.日志

2.堆栈

完结散花~~~