Java中几种简单的锁

锁的种类

1、可重入锁

synchronized和ReentrantLock都是可重入锁。

如何理解重入性–基于线程的分配，而不是基于方法条用的分配

public synchronized void A(){

             System.out.println("进入A方法");

             B();

}

public synchronized void B(){

             System.out.println("进入B方法");

}

上述方法，如果synchronized如果不具备可重入性，那么线程已经持有该对象的锁，也一直在申请锁，这样会造成线程A永远不会得到锁，由于具备可重入性，所以不会造成上述现象

2、可中断锁

synchronized是不可中断锁，Lock是可中断锁

举例：线程A在执行锁中的代码，线程B一直在等待获取该锁，那可以中断它，这种就是可中断锁

public class DeadLock implements Runnable{
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;
    public DeadLock (int lock) {
        this.lock = lock;
    }
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                    } catch (Exception e) {
                        lock2.lockInterruptibly();
                        }
                }else{
                    lock2.lockInterruptibly();
                    try {
                        Thread.sleep(300);
                        } catch (Exception e) {
                            lock1.lockInterruptibly();
                            }
                    }
            } catch (Exception e) {
                e.printStackTrace();
                }finally{
                    if (lock1.isHeldByCurrentThread()) { 
                        lock1.unlock();
                        }
                    if (lock2.isHeldByCurrentThread()) {
                        lock2.unlock(); 
                        }
                    }
        }
    public static void main(String[] args) {
        DeadLock dk1 = new DeadLock(1);
        DeadLock dk2 = new DeadLock(2);
        Thread t1 = new Thread(dk1);
        Thread t2 = new Thread(dk2);
        t1.start();
        t2.start();
        try {
            Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                }
        t2.interrupt();
        }
    }

3、限时锁：

给一个线程等待的事件，超过时间，自动放弃线程

tryLock()方法有两个参数,第一个是等待时长,第二个是计时单位,如果超过给定时间还没有得到锁就会返回false,如果拿到锁就会返回true.