高并发锁Lock的详细使用

Lock的基本属性

*  1)Lock是手动锁，加锁和释放必须得手动进行
*  2)使用ReentrantLoock，尝试锁定，“tryLock”,这样无法锁定，或者在指定时间内无法锁定，
*    线程可以决定是否等待
*  3)使用ReenTrantLock还可以调用lockInterruptibly方法，可以对线程的interrupt做成响应
*     在一个线程等待的过程中，可以被打断
*  4)ReentrantLock还可以指定为公平锁(让等待时间最长的得到锁) Lock lock=new ReentrantLock(true)
*  5）Condition producer=lock.newCondition()；
*     Condition的方式可以更加精确的指定哪些线程被唤醒
*

首先介绍tryLock的基本使用

public class testLock {
   

    Lock lock=new ReentrantLock();
    void m1(){
        try {
            lock.lock();
            for(int i=0;i<10;i++){
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            {
                lock.unlock();
            }
        }
    }

    /*
    使用trylock进行锁定，不管锁定与否，方法都将继续执行
    也可以执行tryLock的时间，由于tryLock(time)抛出异常，所以注意unLock的处理，必须放到finally中
     */
    void m2(){
        /*boolean locked=lock.tryLock();
        System.out.println("m2...."+locked);
        if(locked) lock.unlock();
        */
        boolean locked=false;
        try{
            locked=lock.tryLock(5,TimeUnit.SECONDS);
            System.out.println("m2.."+locked);
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            if (locked)lock.unlock();
        }


    }

    public static void main(String[] args) {
        testLock r1=new testLock();
        new Thread(r1::m1).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(r1::m2).start();

    }
}

关于响应中断的举例

public class testLock1 {
    public static void main(String[] args) {
        Lock lock=new ReentrantLock();
        Thread t1=new Thread(()->{
           try{
               lock.lock();
               System.out.println("t1 start");
               TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
               System.out.println("t1 end");
           }catch (InterruptedException e){
               System.out.println("Interrupte 1");
           }finally {
               lock.unlock();
           }
        });
        t1.start();
        //
        try{
            TimeUnit.SECONDS.sleep(5);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        Thread t2=new Thread(()->{
            try{
                lock.lockInterruptibly();//可以对interrupt()做出响应
                System.out.println("t2 start");
                TimeUnit.SECONDS.sleep(5);
                System.out.println("t2 end");
            }catch (InterruptedException e){
                System.out.println("Interrupte 2");
            }finally {
                if (!((ReentrantLock) lock).isLocked())
                    lock.unlock();
            }
        });
        t2.start();
        try{
            TimeUnit.SECONDS.sleep(5);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        t2.interrupt();//打断线程2的等待
    }
}

关于Condition 的使用，可以使用以下这篇关于手写固定同步容器的博客，很有借鉴性
https://www.cnblogs.com/jpfss/p/9913344.html