多线程---重入锁

package com.yao.item;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 重入锁
 */
public class IntLock implements  Runnable {

    public  static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    /**
     * 控制加锁的顺序，避免构造死锁
     */
    public  IntLock(int lock){
        this.lock = lock;

    }
    @Override
    public void run() {
        try {
            if (lock == 1) {

                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException interruptedException) { }
                lock2.lockInterruptibly();

            }else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);


                } catch (InterruptedException e) { }
                lock1.lockInterruptibly();
            }


        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (lock1.isHeldByCurrentThread()){
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()){
                lock2.unlock();
            }
            System.out.println(Thread.currentThread().getId()+" ：线程退出");
        }
    }
    

    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();t2.start();
        Thread.sleep(1000);
        //中断t2线程
        t2.interrupt();

    }

    }

线程t1和t2启动后，t1先占用lock1，再占用lock2；t2先占用lock2，再请求lock1。因此，很容易形成t1和t2之间的相互等待。在这里，对锁的请求，统一使用lockInterruptibly()方法。这是一个可以对中断进行响应的锁申请动作，即在等待锁的过程中，可以响应中断。

ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。 ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。

最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程。