JAVA锁

公平锁非公平锁

• 公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。
• 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比现申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象。

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

区别

并发包中的 ReentrantLock 的创建可以指定构造函数 的 boolean类型来得到公平锁或者非公平锁，默认是非公平锁！
公平锁：就是很公平，在并发环境中，每个线程在获取到锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己。
非公平锁：非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就会采用类似公平锁那种方式。
Java ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。对于Synchronized而言，也是一种非公平锁。

public class ReenTrantLock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"AA").start();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"BB").start();
        new Thread(()->{
            for (int i = 0; i <40; i++) {
                tickets.sale();
            }
        },"CC").start();
    }

}

class Tickets{
    private int ticket=30;
    ReentrantLock lock = new ReentrantLock(true);
    //卖票
    public void sale(){
        lock.lock();
        try {
            if (ticket>0) {
                System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + ",剩余" + ticket);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

可重入锁

可重入锁（也叫递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也就是说，线程可以进入任何一个它已经拥有的锁，所同步着的代码块。 好比家里进入大门之后，就可以进入里面的房间了；
ReentrantLock、Synchronized 就是一个典型的可重入锁；
可重入锁最大的作用就是避免死锁

synchronized隐式------可重入锁

public class SyncLockDemo {

    //synchronized隐式锁，上锁解锁自动完成
    //synchronized同步方法验证synchronized是可重入锁
    public synchronized void add(){
        add();
    }

    public static void main(String[] args) {

        new  SyncLockDemo().add();//java.lang.StackOverflowError
        //
        Object o = new Object();

        //synchronized同步代码块验证synchronized是可重入锁
        new Thread(()->{
            synchronized (o){
                System.out.println(Thread.currentThread().getName()+"外层");

                synchronized (o){
                    System.out.println(Thread.currentThread().getName()+"中层");

                    synchronized (o){
                        System.out.println(Thread.currentThread().getName()+"外层");
                    }
                }
            }
        },"T1").start();
    }
}

lock显示----可重入锁

public class SyncLockDemo {


    public static void main(String[] args) {
        Object o = new Object();

        Lock lock = new ReentrantLock();
        //演示lock显示锁
        new Thread(()->{
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"外层");

                try {
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+"中层");

                    try {
                        lock.lock();
                        System.out.println(Thread.currentThread().getName()+"内层");
                    } finally {
                        lock.unlock();
                    }
                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        },"T1").start();
    }
}

死锁

什么是死锁？
两个或两个以上线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，如果没有外力干涉，就无法执行下去。

产生死锁的原因：

• 系统资源不足
• 进程运行推进顺序不合适
• 资源分配不当

快速写一个死锁

public class deadLockDemo {

    static Object a = new Object();
    static Object b = new Object();
    public static void main(String[] args) {

        new Thread(()->{
            synchronized (a){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"持有锁a，试图获取锁b");

                synchronized (b){
                    System.out.println(Thread.currentThread().getName()+"获取锁b");
                }
            }
        },"A").start();

        new Thread(()->{
            synchronized (b){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"持有锁b，试图获取锁a");

                synchronized (a){
                    System.out.println(Thread.currentThread().getName()+"获取锁a");
                }
            }
        },"B").start();
    }
}

验证是否死锁

(1)jps 类似于linux ps - ef
(2)jstack jvm自带堆栈跟踪工具

1、查看JDK目录的bin目录
2、使用 jps -l 命令定位进程号
3、使用 jstack 进程号 找到死锁查看