Lock接口

独占锁：在任一时刻只能有一个线程获取到锁，可以执行。其他线程被阻塞，进去等待队列
共享锁：共享锁允许多个线程同时运行，通常情况下，共享锁内部维护了若干个执行许可，每个线程执行的时候获取一个许可，运行结束的时候释放许可。当一个线程请求执行时，如果共享锁已经没有许可，那么该线程进入等待队列。
注：可以认为独占式同步组件是共享式同步组件的一个特例，其只有1个许可

lock接口独占锁示例

import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {

    public static void main(String[] args) {
        final Lock lock = new ReentrantLock();
        new Thread("Thread A"){
            @Override
            public void run(){
                lock.lock();//加锁
                try{
                    work();
                }finally {
                    lock.unlock();//释放锁
                }
            }
        }.start();
        new Thread("Thread B"){
            @Override
            public void run(){
                lock.lock();//加锁
                try{
                    work();
                }finally {
                    lock.unlock();//释放锁
                }
            }
        }.start();
        new Thread("Thread C"){
            @Override
            public void run(){
                lock.lock();//加锁
                try{
                    work();
                }finally {
                    lock.unlock();//释放锁
                }
            }
        }.start();
        System.out.println("start--------------");

    }
    
    @SuppressWarnings("static-access")
    public static void work(){
          try {
                System.out.println(Thread.currentThread().getName()+" started to work,currrentTime:"+new Date().toLocaleString());
                Thread.currentThread().sleep(1000);
                System.out.println(Thread.currentThread().getName()+" wnd work,currrentTime:"+new Date().toLocaleString());
            } catch (InterruptedException e) {
                e.printStackTrace();
        }
    }
}

运行结果

start--------------
Thread B started to work,currrentTime:2017-1-20 16:51:09
Thread B wnd work,currrentTime:2017-1-20 16:51:10
Thread A started to work,currrentTime:2017-1-20 16:51:10
Thread A wnd work,currrentTime:2017-1-20 16:51:11
Thread C started to work,currrentTime:2017-1-20 16:51:11
Thread C wnd work,currrentTime:2017-1-20 16:51:12

分析

从结果看出，B先获取到锁，等到执行完毕，A才获取到锁，才开始执行

ReentranLock共享锁示例

public class ReentrantLockDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        System.out.println(lock.getHoldCount());//没有调用lock之前，hold count为0
        lock.lock();
        System.out.println(lock.getHoldCount());
        lock.lock();
        System.out.println(lock.getHoldCount());
        lock.unlock();
        System.out.println(lock.getHoldCount());
        lock.unlock();
        System.out.println(lock.getHoldCount());
    }
}

运行结果

0
1
2
1
0

分析

一个线程(本案例就是主线程)的确可以多次持有同一个锁。每当调用lock方法时，次数+1，每当调用unlock方法时，次数-1。我们看到出现了2，
这事实上就体现了所谓的可重入。
需要注意的是：当getHoldCount()不为0的时候，表示锁当前正在被某个线程使用，只有当其为0的时候，其他线程才有机会获取这个锁