ReentrantLock源码解析_we don‘t need to do so to check if current thread

        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

###  非公平锁NonfairSync的实现


在ReentrantLock还有两个内部类其中一个就是NonfairSync他继承了抽象类Sync 

static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;

    //非公平锁的具体实现
    final void lock() {
        // CAS比较state变量值 去更改state的值为1 尝试去获取锁
        if (compareAndSetState(0, 1))
            //获取锁成功。成功则将独占锁线程设置为当前线程  
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 失败的情况下、 再次请求同步状态
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

//AQS 中的方法 尝试获取锁
public final void acquire(int arg) {
     // tryAcquire(arg) 获取锁成功为true 否则为false
    if (!tryAcquire(arg) &&
        // addWaiter 在同步队列中的队尾新增一条数据

        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

         
        selfInterrupt();
}

//AQS 中的方法 尝试获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        一直循环
        for (;;) {
              // 获取当前节点的前置节点
            final Node p = node.predecessor();
            
            if (p == head && tryAcquire(arg)) {
                 //获取前置节点为头部节点，并且头部节点已经获取锁了
                 // 设置头部节点为当前接口
                setHead(node);
                // 并将已经获取锁的节点的后驱节点置为null 便于垃圾回收
                p.next = null;
                failed = false;
                return interrupted;
            }
            //响应中断 判断当前节点的前置节点是否为头部接口并且当前节点的线程是否被中断 
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        //获取锁失败。那么就会取消获取锁。将node节点的状态置为cancel取消状态
        if (failed)
            cancelAcquire(node);
    }
}

acquire具体的实现逻辑在sync的nonfairTryAcquire方法
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 尝试获取state状态
int c = getState();
// 如果state 说明资源没有被占用
if (c == 0) {
//CAS成功后变获取锁、
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//如果资源被占用，并且被占用的线程是当前线程那么state++
else if (current == getExclusiveOwnerThread()) {
//如果资源被占用
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error(“Maximum lock count exceeded”);
setState(nextc);
return true;
}
return false;
}

 公平锁NonfairSync的实现

static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

     
   // 公平锁获取资源的方式 与非公平说最大的区别在
     // hasQueuedPredecessors方法
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

// 按照严格的队列的FIFO的规则进行 只有当前前程是头部node 头部node的线程信息是当前线程才能获取锁
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}

### 解锁的过程


 

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {

最全的Linux教程，Linux从入门到精通

======================

1. linux从入门到精通(第2版)

2. Linux系统移植

3. Linux驱动开发入门与实战

4. LINUX 系统移植 第2版

5. Linux开源网络全栈详解 从DPDK到OpenFlow

第一份《Linux从入门到精通》466页

====================

内容简介

====

本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。

本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。

需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！