第一把锁

1：设计原理

1.1：循环等待法

　　锁的作用是什么？就是使多线程同步执行，避免异步出现的脏读错误。从这个角度出发我们可以很自然的象到该如何设计一个锁尼？

我们可以这样设计，当有两个线程要访问待同步的代码块时，我们将该同步代码块的使用权交给第一个访问的线程，使其能够顺利运行，而在第一个线程没有结束使用的之前，其他线程如果也要访问该同步代码块，则会循环等待，知道第一个线程结束了同步代码块的使用。基于这个想法我们实现下面代码。

1.2：循环等待法的代码实现

package reentrantlockTest;

/**
 * @author ：dazhu
 * @date ：Created in 2020/4/12 8:43
 * @description：朱超成实现的第一把锁
 * @modified By：
 * @version: v1$
 */
public class ZccLock {
    //锁的初始状态为0
    private int status = 0;

    public void lock() {
        //如果锁状态不为0，则一直循环
        //当其他线程在上一个线程没有unlock时，进入lock方法，则会一直进入循环等待
            while (this.status != 0) {
            }
            //如果状态为0，则置1。使其他线程进入后，一直等待。
            this.status = 1;
    }
    public void unlock(){
        //锁状态置0
        this.status = 0;
    }
}

这是最基本的实现方式我们做个测试demo看一下；

package reentrantlockTest;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ：dazhu
 * @date ：Created in 2020/4/12 8:07
 * @description：
 * @modified By：
 * @version: $
 */
public class Main {
    //可重入锁
    public static ReentrantLock reentrantLock = new ReentrantLock();
    //自建锁
    public  static ZccLock zccLock = new ZccLock();
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<10;i++) {
            Thread t1 = new Thread(Integer.toString(i)) {
                @Override
                public void run() {
                    testSync();
                }
            };
            t1.start();
        }
    }

    public static void testSync(){
        //reentrantLock.lock();
        //使用自建锁
        zccLock.lock();
        System.out.println(Thread.currentThread().getName());
        try{
            Thread.sleep(100);
        }
        catch (InterruptedException ie){
            ie.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
        //reentrantLock.unlock();
        //使用自建锁
        zccLock.unlock();
    }
}

　　经过测试发现；只能循行第一个线程，其他线程似乎并没有从循环等待中退出，也就是status的改变没有被其他线程获得！为什么会这样呢？因为虽然第一个线程在unlock中修改了status为0，但是其他线程的内部缓存中并没有还想其改变为0了，依然里面是旧值，所以依然陷入了循环。那么怎么解决尼？我们可以使用volatile关键字来创建status！这样就可以在第一个线程unlock的时候，其他线程也发现了该值被改变了，从而通过总线嗅探技术来从主存中重新获取新值。经过修改发现这两个线程了同步运行了。

1.3：依然存在的问题

　　当我们增加线程数量时，发现众多线程之间依然不会同步执行这是为什么尼？可能原因会是什么尼？根据这个现象，显然线程之间异步执行了该代码块。这是怎么发生的尼？

　　这是由于我们循环比较和置1的这两行代码不是原子操作！怎么理解尼？有其他线程进入lock中的循环比较和置数之间，导致多线程其实自己status依然是0，这样就会多线程就异步执行了！如何解决尼？我们使用同步关键字。。。。。这不是套娃嘛？我们的目的就是创建自己的锁，怎么还是用java的锁关键字了。不过我们可以暂时使用synchronized来作证是不是我们分钟的原因。

package reentrantlockTest;

/**
 * @author ：dazhu
 * @date ：Created in 2020/4/12 8:43
 * @description：朱超成实现的第一把锁
 * @modified By：
 * @version: v1$
 */
public class ZccLock {
    //锁的初始状态为0
    //使用volatile可以保证，当前线程unlock后，改变的status可以被其他线程循环在while的线程
    //发现到，status变为0了，以适他们退出while，得以运行同步块代码。
    //但是如果不使用volatile的话，每一个线程的中自己内部缓存的status不是最新的，改变后的，而是依然1
    private volatile int status = 0;

    public void lock() {
        //如果锁状态不为0，则一直循环
        //当其他线程在上一个线程没有unlock时，进入lock方法，则会一直进入循环等待
        synchronized (this) {
            while (this.status != 0) {
            }
            /**
             * 依然有问题，如果当t1线程执行到这里后，
             * 发生了切换，进入t2线程，那么t2线程因为t1线程没有完成修改了status=1
             * 所以t2依然可以执行同步的代码段。
             * t1和t2可以异步的执行同步的代码段。
             * 只有将前面的比较和下面的置1做成同步块，才能避免错误。
             * 这不是套娃吗？
             */
            //如果状态为0，则置1。使其他线程进入后，一直等待。
            this.status = 1;
        }
    }
    public void unlock(){
        //锁状态置0
        this.status = 0;
    }
}

结果如下：

 果然，线程之间没有异步执行！那如何解决这个问题尼？只要我们可以将循环比较和辅助做成原子操作就可以啦！

1.4：最终版本