为什么需要Lock，而不是直接用synchronized

    // 支持中断的 API
    void lockInterruptibly() throws InterruptedException;
    // 支持超时的 API
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 支持非阻塞获取锁的 API
    boolean tryLock();

    class X {
      /** 锁，应是私有的、不可变的、不可重用的。Integer 和 String 类型的对象不适合做锁。如果锁发生变化，就意味着失去了互斥功能。
      Integer 和 String 类型的对象在 JVM 里面是可能被重用的，除此之外，JVM 里可能被重用的对象还有 Boolean，
      重用意味着你的锁可能被其他代码使用，如果其他代码synchronized(你的锁)，而且不释放，那你的程序就永远拿不到锁，这是隐藏的风险。*/
    	private final Lock rtl = new ReentrantLock();
    	int value;
    	public void addOne() {
    		// 获取锁
    		rtl.lock();
    		try {
    			value+=1;
    		} finally {
    			// 保证锁能释放
    			rtl.unlock();
    		}
    	}
    }

    		private volatile int state;
    
    /** * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }
    /** * Sets the value of synchronization state.
     * This operation has memory semantics of a {@code volatile} write.
     * @param newState the new state value
     */
    protected final void setState(int newState) {
        state = newState;
    }
    //获取锁
    	final boolean nonfairTryAcquire(int acquires) {
          	final Thread current = Thread.currentThread();
            int c = getState();//读取state值
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//更新state值
                return true;
            }
            return false;
        }
    
    protected final boolean tryRelease(int releases) {
            int c = getState() - releases;//读取state值
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);//更新state值
            return free;
        }