并发编程学习笔记(4)----jdk5中提供的原子类及Lock使用及原理

（1）jdk中原子类的使用：

jdk5中提供了很多原子类，它会使变量的操作变成原子性的。

原子性：原子性指的是一个操作是不可中断的，即使是在多个线程一起操作的情况下，一个操作一旦开始，就不会被其他线程干扰。

jdk中的rt.jar中提供给了很多的原子性操作类。它们是位于java.util.concurrent.atomic包中，如图：

由图可以看到，jdk提供了很多基础类型的原子类操作，已经对象（AomicReference）原子操作类，数组的原子操作类，已经对象属性院子操作类（AtomicReferenceFieldUpdater）等，篇幅关系不会一一的放使用Demo，只放AtomicReferenceFieldUpdater这个相对特殊一点的类的使用案例，感兴趣的同学可以自己去java.util.concurrent.atomic查看源码，并一一实验。示例代码：

package com.wangx.thread.t4;

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class AtomicReferenceFieldUpdaterTest {
    //使用newUpdater方法构建实例，第一个参数为需要操作对象，第二个参数为需要操作的属性的数据类型字节码文件，第三个为属性名字
    AtomicReferenceFieldUpdater<User, String> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(User.class, String.class, "name");
    User user = new User();
    public void printName (String name) {
        atomicReferenceFieldUpdater.set(user,name);
        System.out.println(user.getName());
    }
    public static void main(String[] args) {
        AtomicReferenceFieldUpdaterTest atomicReferenceFieldUpdaterTest = new AtomicReferenceFieldUpdaterTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    atomicReferenceFieldUpdaterTest.printName("张三");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    atomicReferenceFieldUpdaterTest.printName("李四");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    atomicReferenceFieldUpdaterTest.printName("网五");
                }
            }
        }).start();
    }
}

当不知道对应类型的原子类怎么构建时，源码是一个很好的选择，如上案例，进入源码，找到newUpdater，方法的注释会很明确的告诉你每个参数代表的意思，如图：

原子性操作类的原理：

进入任意一个原子类中，都可以看到，其实它最终都会调用sun.misc.Unsafe类中的compareXXX方法来操作变量，Unsafe不属于java标准，它跟C语言一样可以拥有操作指针空间的能力，但是过度的使用会使的出错几率很大，所以java也不建议我们使用它，但是它提供的一些锁的机制却是被原子类使用，这里使用的就是Unsafe中提供的cas算法，cas算法就是通过不断的比较当前值与期望值，最终来确保线程安全的。

（二）Lock锁的使用及原理：

Java中实现了很多的锁，读写锁，重入锁等，他们位于java.util.concurrent.locks包中，Lock接口提供了很多方法使得我们在并发场景下保证线程安全。的我们这里使用重入锁为例演示lock的使用。代码为：

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Sequence {

    private int value;

    //使用重入锁
    Lock lock = new ReentrantLock();

    public int getValue () {
        lock.lock();
        value++;
        lock.unlock();
        return value;
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
    }
}

前面已经演示过该代码在不适用锁或synchronized时会产生的线程安全问题，也使用了synchronized来避免了线程安全问题，这里使用Lock的lock和unlock也能实现线程的安全，同时也能在自己想要释放锁的位置unlock锁，同时提供了几个方法让我们在开发中线程的操作变得更加的便利。所以Lock也是有其存在的意义的，在线程开发非常复杂的情况下，使用Lock会比synchronized更加简单。

这里我们简单的实现一个基于synchronized的Lock。

首先构建一个需要使用锁的场景，然后一步步分析，最后实现锁，

　　1）构建使用场景，Sequence为例

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;

public class Sequence {

    private int value;

    //使用重入锁
    Lock lock = new MyLock();

    public int getValue () {
        //获取锁
        lock.lock();
        value++;
        //释放锁
        lock.unlock();
        return value;
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(sequence.getValue());
                }
            }
        }).start();
    }
}

实现是为了我们更好的理解，所以只实现lock和unlock方法。

由场景可以看出，当线程进入方法时，需要获取锁，实现的方式就是我们可以给lock方法加上synchronized关键字，以Lock对象作为内置锁，实现方式为：

 public synchronized void lock() {}

同时unlock也需要synchronized来进行同步，所以当方法进入时这里就拿到了锁，同时我们还应该维护一个boolean变量isLocked来标记该锁是否已经被获取到了，初始值为false，所以当线程第一次进来时获取锁，并将赋值为true,表示锁已经被占用，其他线程进入等待。

 public synchronized void lock() {
        while (isLocked) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isLocked = true;
    }

使用while更能确保在某次意外唤醒之后其他线程仍能进行等待。

当调用unlock时，我们需要的释放锁，那么这里就是需要唤醒等待的线程，并将锁状态更改为未被占用，即isLocked = false;

代码为：

 public synchronized void unlock() {
        isLocked = false;
        //唤醒等待的线程
        notify();
    }

这样一个简易的Lock就实现了，但是synchronized是一个重入锁，即当前线程拿到该线程后，可以进入到其他加了该内置锁的方法中继续执行，而我们的锁则是会出线锁无限等待的过程，示例代码：

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;

public class Demo {

    private Lock lock = new MyLock();
    public void a () {
        lock.lock();
        System.out.println("a");
        b();
        lock.unlock();
    }

    private void b() {
        lock.lock();
        System.out.println("b");
        lock.unlock();
    }

    public static void main(String[] args) {
        Demo demo = new Demo();

        demo.a();
    }
}

运行程序时会发现，当a打印之后，线程将会一直等待着，分析原因可以知道，当第一次进入a方法时。获取到所，此时的isLocked就变成了true，继续执行进入b方法是，调用lock方法，就会使线程一直等待，出不了while循环，所以导致线程挂起，所以还需要维护两个变量，一个是lockBy用来判断是否是当前线程，此时情况是执行两个方法是同一个线程，同时维护一个线程重入次数，在多层次调用时需要在适当的情况下唤醒其他线程。

package com.wangx.thread.t4;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自己实现自己的锁
 */
public class MyLock implements Lock {

    /**
     * 判断线程是否拿到锁
     */
    private boolean isLocked = false;
    /**
     * 维护当前线程
     */
    private Thread lockBy = null;

    private int lockCount = 0;
    /**
     * lock方法
     */
    @Override
    public synchronized void lock() {
        //获取当前线程
        Thread currentThread = Thread.currentThread();
        //判断进来的线程是否是当前线程
        while (isLocked && currentThread != lockBy) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //保存当前线程
        lockBy = currentThread;
        //标记锁重入次数
        lockCount++;
        isLocked = true;
    }

    @Override
    public synchronized void unlock() {
        Thread currentThread = Thread.currentThread();
        //当不是当前线程进入时，什么都不用做
        if (currentThread == lockBy) {
            //调用一次unlock减一次，实现多重调用时多个unlock
            lockCount--;
            //当所有重入锁释放完成之后，唤醒等待线程
            if (lockCount == 0) {
                isLocked = false;
                //唤醒等待的线程
                notify();
            }
        }
    }
}

第一次进入lock方法时，while条件为false，此时维护当前线程到lock，当调用b方法时，由于此时的线程为同一个，所以也不会执行wait,此时lockCount为2（第一次进入也自增了），执行打印b，然后再执行b方法的unlock，lockCount--,然后回到a方法，在执行unlock，lockCount--,此时lockCount为0，表示该锁可以释放了，所以将isLocked标记为false，可以被其他线程拿到，唤醒其他等待的线程。这样就真正的实现了一个可重入的简易的自己锁。再次执行测试，将会发现a,b打印，线程退出。