ReentrantLock可重入锁

aqs(AbstractQueuedSynchronizer)是一个用于构建锁和同步器的框架
java.util.concurrent包中ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock、SynchronousQueue都是通过aqs实现的

ReentrantLock为例实现细节

ReentrantLock.lock()

public void lock() {
    sync.lock();
}

ReentrantLock.NonfairSync.lock()

final void lock() {
    //第一个线程通过cas修改state状态，0->1。修改成功返回true
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());    //记录当前独占线程
    else
        acquire(1); //如果没有获取到锁,调用AQS.acquire(1);
}

AQS.acquire(1);

public final void acquire(int arg) {
    //tryAcquire是aqs的模板方法，如果使用的非公平锁ReentrantLock.NonfairSync会重写这个方法
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

ReentrantLock.NonfairSync.tryAcquire()

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

//此方法在NonfairSync父类Sync中
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    //如果状态state被其他线程释放后，修改为0。那么此时当前线程就可以直接拿到执行权，并返回true。AQS.acquire也就没有必要在将线程放入锁池中了。
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } 
    //如果state<>0那么说明锁被其他线程占有，还没有释放。但是要判断一下是不是线程自己占有的。如果是当前线程，那么将state+1b,返回true。AQS.acquire也就没有必要在将线程放入锁池中了。
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            //这个异常导致的原因待分析.............
            throw new Error("Maximum lock count exceeded"); 
        setState(nextc);
        return true;
    }
    //如果既没有拿到执行权又不是当前线程重入，那么就说明锁已被其他线程占用，返回false。继续执行AQS.acquire方法中的 acquireQueued方法，将当前线程挂起放入锁池中
    return false;
}

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

//线程没有获取到state锁状态，就需要放入到一个锁池中（aqs中链表）,然后在将这个线程挂起等待唤醒。
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) {
        //如果aqs队列存在尾节点，那么就把新的node节点的前节点执行tail
        //         tail <- node 相当于
        node.prev = pred;
        //这一步cas操作是把aqs.tail 换成新加入链表的 node节点
        //         node(原tail对象) <- aqs.tail(新node节点对象)
        if (compareAndSetTail(pred, node)) {
            //这一步相当于把原tail对象的next指向 新node节点
            //     node(原tail对象).next -> aqs.tail(新node节点对象)
            pred.next = node;
            return node;
        }
    }
    //如果一共三个线程，那么第一个线程不会进入到这个addWaiter方法，第二个线程会进入enq方法，将当前线程封装的node节点放入队列，head与tail相同。当第三个线程就会满足if（pred != null）逻辑。
    enq(node); 
    return node;
}

//将刚加入链表中node的线程挂起等待唤醒
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        
        for (;;) {
            //1.取出node的前置节点
            final Node p = node.predecessor();
            //2.然后判断这个node的前置节点是不是aqs中的头节点，如果是头节点说明马上就到当前这个node节点了，所以需要在尝试获取一下锁状态（state）。因为在这个过程中很有可能aqs那个头节点已经release了，并且锁状态就变成0了。
            if (p == head && tryAcquire(arg)) {
                //3.如果aqs头节点释放了那么当前节点就不需要放入锁池了再挂起了。将当前节点设置为aqs头节点，然后将aqs原头结点设置成null，等GC。
                setHead(node);
                p.next = null; // help GC 
                
                failed = false;
                
                return interrupted;
            }
            //如果不符合第一个if判断，再判断是否需要挂起等待，如果需要阻塞线程。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
        
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

自己根据理解实现自定义的锁工具

以下是根据aqs理解实现的，没有经过大量验证一定会存在无数bug，并且没有考虑锁重入，线程中断，执行效率等等问题。

aqs的主要技术：自旋＋volatile＋CAS、LockSupport、锁池

MyLock.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;

public class MyLock {

    //锁状态
    AtomicInteger status = new AtomicInteger(0);
    
    //锁池（所有被阻塞的线程）
    List<Thread> threadList = Collections.synchronizedList(new ArrayList<Thread>());
    
    //上锁(获取程序执行权)
    public void lock() {
        //偏向
        if(status.compareAndSet(0, 1)) {
            return;
        }
        //轻量
        for (int i = 0; i < 10; i++) {
            if(status.compareAndSet(0, 1)) {
                return;
            }
        }
        //重量
        while(true) {
            if(status.compareAndSet(0, 1)) {    //当线程被唤醒时，需要把状态修改成占用状态
                return;
            }
            threadList.add(Thread.currentThread()); //并放入到锁池中去，等待unLock操作随机唤醒
            LockSupport.park(this); //当前线程阻塞
            
        }
        
    }
    
    //解锁(其实是解除锁池中线程的阻塞状态)
    public void unLock() {
        status.getAndSet(0);    //将锁状态修改成未占用状态
        if(!threadList.isEmpty()) {
            //随机从锁池中恢复一个线程（模拟非公平锁）
            LockSupport.unpark(threadList.remove(new Random().nextInt(threadList.size()))); 
        }
    }
}

测试类

public class Test3{
    
    static MyLock lock = new MyLock();
    
    static int count = 0;
    
    public static void main(String[] args) {
        
        CountDownLatch c = new CountDownLatch(10);
        
        for(int i=0; i<10; i++) {
            new Thread(()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(1); //方便模拟出count是线程不安全的状态值
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count();
                c.countDown();
            }).start();
        }
        
        try {
            c.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(count);
    }
    
    public static void count() {
        lock.lock();
        
        for(int i=0; i<1000; i++) {
            count++;
        }
        
        lock.unLock();
    }
}

源码中非公平锁与公平锁的区别在于tryAquire，非公平锁对于新线程会先去竞争state状态，如果竞争成功就可以执行，才不管你锁池里有没有等待的线程。如果竞争不到没办法进入锁池排队去。而公平锁对于新线程会先去判断锁池里有没有等待的线程如果有，不好意思直接进锁池排队去。
线程一旦进去了锁池那么两者就没有区别了都排着队一个一个的从头部节点释放出来。

如果非公平锁能像自己实现的那样能从锁池中随机释放线程锁去争抢执行权，从全部线程来看是不是更不公平一些。

juc.Condition

线程之间协作，比如一个阻塞队列。push方法是向队列添加值，pull方法是拉取值。阻塞队列就是如果队列没有内容pull方法阻塞直到队列有值。那么通过Condition的await、signal实现阻塞队列。

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLock_main {

    //测试阻塞队列
    public static void main(String[] args) {
        
        MyBlockingQueue<String> mb = new MyBlockingQueue<String>();
        
        //输入线程
        new Thread(()->{
            Scanner s = new Scanner(System.in); //控制台输入内容
            while(true) {
                String str = s.nextLine();
                if("exit".equals(str)) {
                    System.exit(0); //退出
                } else {
                    System.out.println("输入了：" + str);
                    mb.push(str);
                }
            }
        }).start();
    
        //接收线程A
        new Thread(()->{
            for(;;) {
                System.out.print("  乙pull " + mb.pull());
            }
        }).start();
        
        //接收线程B
        new Thread(()->{
            for(;;) {
                System.out.print("  丙pull " + mb.pull());
            }
        }).start();
    }

}

/**
 * 阻塞队列
 * 
 * @author hdx
 * @date 2020年10月16日
 */
class MyBlockingQueue<T>{
    
    private List<T> list = new LinkedList<T>();
    
    ReentrantLock reentrantLock = new ReentrantLock();
    Condition conditionA = reentrantLock.newCondition();
    
    public void push(T t) {
        reentrantLock.lock();
        try {
            list.add(t);    //添加值
            conditionA.signal();    //通知await可以执行了
        } finally {
            reentrantLock.unlock();
        }
    }
    
    public T pull() {
        reentrantLock.lock();
        try {
            while(true) {
                if(list.size() > 0) {   //如果有值就返回值
                    return list.remove(0);
                } else {
                    try {
                        conditionA.await(); //如果没有值就在此等着。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } finally {
            reentrantLock.unlock();
        }
    }
}

conditionA.await() 与 wait相同
conditionA.signal() 与notify相同
conditionA.signalAll()与notifyAll相同

juc.Condition实现细节

await方法分析

public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();  //condition对象内部也有一个单向链表，向尾部增加节点。
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
 }

signal方法分析
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,544评论 6赞 501
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,430评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,764评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,193评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,216评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,182评论 1赞 299
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,063评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,917评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,329评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,543评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,722评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,425评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,019评论 3赞 326
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,671评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,825评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,729评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,614评论 2赞 353