Object notify/wait实现锁

2019独角兽企业重金招聘Python工程师标准>>>

突发奇想利用Object的notify wait来实现简单的锁。我们知道Java中的每个Object都有一个监视器,当获取到对象monitor后，调用对象wait会阻塞当前调用线程，当调用对象notify/notifyAll会唤醒等待线程。利用这个特性，可以简单的实现一个锁的功能。

Lock的两个基本方法

package com.yao.monitor;

/**
 * Created by robin.yzb .
 */
public interface Lock {

    void lock();

    void unlock();
}

Lock具体实现

我们利用Object的wait /notifyAll来实现未获取到锁时，线程进入等待队列，当锁释放时，唤醒等待队列里的线程进行重新获取锁。同时通过一个原子变量来保存锁持有线程，作为判断是否重入的依据，另一个原子变量记录重入次数记录。

package com.yao.monitor;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/**
 * Created by robin.yzb .
 */
public class WaitNotifyLock implements Lock {
    private Object obj=new Object();
    private AtomicInteger state=new AtomicInteger(0);
    private AtomicReference<Thread> currentThread=new AtomicReference<>();

    @Override
    public void lock() {
        if (currentThread.get()!=null&&currentThread.get()==Thread.currentThread()) {
            state.incrementAndGet();
        }else {
            while (true) {
                if (currentThread.compareAndSet(null, Thread.currentThread())) {
                    state.set(1);
                    break;
                } else {
                    try {
                        synchronized (obj) {
                                obj.wait();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    @Override
    public void unlock() {
        if (currentThread.get()==null||currentThread.get()!=Thread.currentThread()){
            throw new RuntimeException("illegal unlock operation");
        }
        if(state.decrementAndGet()==0){
            currentThread.set(null);
            synchronized (obj) {
                obj.notifyAll();
            }
        }
    }
}

lock基本逻辑：先判断是否重入，如果当前线程和锁的持有线程相同，则进入重入逻辑；否则进入循环获取，先通过CAS操作进行线程设置，成功则设置当前锁的state状态；如果设置失败，则线程进入等待状态，等待唤醒；

unlock基本逻辑：先判断是否为非法操作，如果当前锁没有被线程占用，或者非法释放未持有的锁则抛出异常；紧接着进入重入逻辑，把state锁次数进行缩减，当全部重入都递减完后，设置锁当前持有线程为null;

Lock测试代码

启动20个线程,每个线程对同一个数进行递加操作一百万次，每一个加操作伴随者锁的获取和释放，最终等待所有线程任务结束后看结果是否正确。

打开 测试重入 注解后面的代码 进行重入测试操作。

package com.yao.monitor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by robin.yzb .
 */
public class TestLock {

    public static void main(String[]args)  {
        try {

            ExecutorService executorService = Executors.newFixedThreadPool(20);
            Lock lock = new WaitNotifyLock();
            final int[] i = {0};
            for (int m = 0; m < 20; m++) {
                executorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        try {

                            for (int j = 0; j < 1000000; j++) {
                                lock.lock();
                                //测试重入
                                //lock.lock();
                                //lock.lock();
                                i[0]++;
                                //lock.unlock();
                                //lock.unlock();
                                lock.unlock();
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                });
            }
            executorService.shutdown();
            while (true) {
                if (executorService.isTerminated()) {
                    System.out.println("所有子线程结束");
                    break;
                }
                Thread.sleep(1000);
            }
            System.out.println(i[0]);
            assert i[0] == 1000000 * 20;
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

基本逻辑介绍完毕，不知道其中有没有漏洞，希望大家留言指导。

https://my.oschina.net/robinyao/blog/820249

转载于:https://my.oschina.net/robinyao/blog/820249