jdk5.0新特性：显式的锁-lock锁

众所周知，synchronized是隐式锁，给方法或代码块加锁就可以实现线程同步，解决多线程并发不安全的问题；何为隐式锁？
：出了作用域，会自动释放锁，不需要你声明什么时候把锁释放

而从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

例子：还是买票的那个问题，一共10张票，三个线程同时去抢，可能出现抢到同一张票的问题，还有抢到第-1张票的问题，以前使用synchronized同步块解决，现在使用lock解决
看代码：

package com.wu;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();

    }
}

class TestLock2 implements Runnable{

    int ticketNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                lock.lock();//加锁，加完锁要记得释放锁
                if(ticketNums >0){
                    try {
                        Thread.sleep((1000));
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(ticketNums --);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

执行结果：

10
9
8
7
6
5
4
3
2
1

Process finished with exit code 0

使用lock锁，需要先定义一个lock锁：
private final ReentrantLock lock = new ReentrantLock();
然后在方法里，加锁：lock.lock();
和解锁：lock.unlock();
显式的声明加锁和解锁。这样比synchronized似乎更麻烦，那我们来看看
synchronized和lock的区别：
1、 Lock是显式锁（(手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
2、Lock只有代码块锁，synchronized有代码块锁和方法锁
3、使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
4、优先使用顺序:
Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)