java并发工具包-ReentrantLock

1. 基础知识

1. ReentrantLock也是重入锁，意思就是能够进行N次获取锁，但是，同样也得释放锁N次。
2. 若设置为公平锁，则锁的获取顺序符合锁请求的绝对时间顺序，也就是FIFO；
3. 默认设置为非公平锁，虽然可能会导致线程饥饿问题；但是，过多的进行线程的切换，也造成了切换的开销。减少线程的上下文切换，可以保证更大的吞吐量。

2. 常用API：

1. lock方法：是无法被打断的；只能一直waiting；
2. lockInterruptibly：可以使用interrupt打断线程。
3. tryLock：尝试获得锁，看是否能够获得锁。能够获得锁，就直接锁住。没有获得锁，线程直接结束，不会waiting。

public class ReentrantLockDemo1 {
    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {        
    	// 1. 测试lock和unlock
        //useLockMethod();

        //2. 可被打断的lock
        //useLockInterruptiblyMethod();

        //3. tryLock
        new Thread(() -> useTryLock()).start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> useTryLock()).start();
    }
    
    private static void useLockMethod() {
        IntStream.rangeClosed(1, 5).forEach(item -> {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " in");
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + " working");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + " end");
                } catch (InterruptedException e) {                   
                	 e.printStackTrace();
                } finally {                   
                	 lock.unlock();
                }
            }).start();
        });
    }
    
    private static void useLockInterruptiblyMethod() throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " in");
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " working");
            } finally {               
            	 lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + " end");
        });

        thread.start();
        TimeUnit.SECONDS.sleep(2);

        Thread thread1 = new Thread(() -> {            
        	try {
                System.out.println(Thread.currentThread().getName() + " in");
                while (true) {                    
                	lock.lockInterruptibly();
                    System.out.println(Thread.currentThread().getName() + " working");
                }            
              } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {                
            	lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + " end");
        });

        thread1.start();
        thread1.interrupt();
    }
    
    private static void useTryLock() {
        // 对于tryLock的写法, 可以参考源码案列
        if (lock.tryLock()) {            
        	try {
                System.out.println(Thread.currentThread().getName() + "获得锁");
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {                
            	e.printStackTrace();
            } finally {                
            	// 一定要释放锁
                lock.unlock();
            }        
         } else {
            System.out.println(Thread.currentThread().getName() + "未获得锁");
        }    
    }
}