解决线程安全问题的方式三：Lock锁

概述： 从JDK5.0开始，我们可以使用Lock接口的实现类ReentrantLock来解决线程的安全问题
同步锁使用它的对象充当

• Lock本身是一个接口，我们具体使用的是Lock的实现类： ReentrantLock
• 1.构造一个ReentrantLock对象
• 2.把需要被同步的代码放到try当中，因为没有什么异常，所以不用写catch，而是写finally
• 3.在try中执行ReentrantLock对象.lock()操作（调用的lock方法是锁定方法），就把try中的代码锁住了，这一段代码就是同步的，是单线程的
• 4.在finally中解锁:ReentrantLock对象.unlock();(调用解锁方法)

说明：
建议优先考虑用Lock锁的方式解决线程安全问题，其次用同步代码块（已经进入了方法体，分配相应的资源），最后才考虑用同步方法（没有同步代码块灵活）

例子：

package test0;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo {
    public static void main(String[] args) {
        window w=new window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");

        t1.start();
        t2.start();
        t3.start();
    }
}
class window implements Runnable {
    private int ticket = 100;

    /*
    ReentrantLock有两个构造器，一个有参（传入一个boolean值，参数名字为fair），一个无参（如果用无参的构造器，相当于boolean的设置为false）。
    也可以传给他true，那么创建的就是一个公平的Lock。同步资源的执行顺序和线程走到这里的顺序相同，先到先执行。不会出现有一个线程先到，执行完了之后
    出去又抢到了执行权，那其他的线程岂不是白等了吗？
    */

    private ReentrantLock l = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try{
                l.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally{
                l.unlock();
            }
        }
    }
}

注意：如果上面使用Lock的方式去解锁，没有问题。
因为线程共用的是同一个Lock对象，但如果上面的程序是采用继承Thread类的方式，还这么写会出问题
要把l加上静态。要保证用同一个锁解锁，也要保证lock对象对这几个线程来说是唯一的

synchronized和ReentrantLock的异同点？
相同： 都可以解决线程安全问题
不同：
ReentrantLock像是一种手动的锁定和解锁（即手动实现同步），如果不执行unlock，那么代码后面都是单线程的

而加了synchronized的大括号，在执行完大括号的内容之后会自动释放锁（锁就是同步监视器的俗称），但在大括号未执行完前都是不可能释放锁的。
unlock就比较灵活，想在哪调用就在哪里调，调用完之后就释放锁