Lock和Synchronized比较

Lock接口和Synchronized关键字都提供了多线程中锁的功能，用来控制多个线程访问共享资源的方式，Synchronized关键字是隐式的获取锁（隐式的可重入锁），但是它将锁的获取和释放固化了，也就是说它只能先获取再释放，而且获取锁的过程不能中断，如果在锁的竞争比较激烈的情况下会导致较长时间的等待而不能中断的情况。Lock是jdk提供的一种显示的获取锁的方式，也提供了Synchronized关键字所不具备的方法，例如：锁的显式的获取和释放，可中断获取锁，超时获取锁（截止时间内无法获取到锁就返回）等方法。但是如果实际问题可以用Synchronized关键字来解决就尽量使用Synchronized关键字，因为java虚拟机对这个关键字在底层做了大量的优化，就性能来说两者差别已经不是太大。而且Synchronized关键字用法简单，在出现异常的时候不会因为没有释放锁而出现死锁的现象。
Lock的标准写法：

public class LockTemplete {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        lock.lock();//不要将锁的获取放在try块中，因为如果出现异常会导致锁的无故释放  
        try{
            // do my work.....
        }finally{
            lock.unlock();
        }
    }
}

上面代码使用的锁是可重入锁，意思允许同一个线程可以多次获取锁，解决的是递归的问题。可重入锁内部又分为公平锁和非公平锁。可以通过构造ReentrantLock的时候决定具体使用的是哪一种。其中所谓的公平锁是指锁的获取顺序严格符合请求的绝对时间，也是就是FIFO，非公平锁是没有这个限制的，可以一个线程同时获取到锁。默认使用的是非公平锁，因为非公平锁可以减少线程上下文的切换，资源开销更小，保证了其更大的吞吐量。（详细请见：java并发编程的艺术，p140）

读写锁非常适合读多写少的场景，它允许多个读线程进入读锁，锁的竞争相较于Synchronized要小的多.
读写锁（ReentrantReadWriteLock）的标准写法：

public class RwLockTemplete {

    static final Map<String,String> map = new HashMap<>();
    static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    static Lock r = reentrantReadWriteLock.readLock();
    static Lock w = reentrantReadWriteLock.writeLock();

    public void put(){
        w.lock();
        try{
            // do my work.....
        }finally{
            w.unlock();
        }
    }
    public void get(){
        r.lock();
        try{
            // do my work.....
        }finally{
            r.unlock();
        }
    }
}

显示锁的等待通知机制：

public class ConditionTemplete {

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void waitc() throws InterruptedException {
        lock.lock();
        try{
            condition.await();
        }finally{
            lock.unlock();
        }
    }

    public void waitnotify() throws InterruptedException {
        lock.lock();
        try{
            condition.signal();
            //condition.signalAll();尽量少使用
        }finally{
            lock.unlock();
        }
    }
}

ThreadLocal类的使用：

private final ThreadLocal<Integer> inCount=new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return new Integer(0);
        }
    };