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