并发编程学习笔记(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打印，线程退出。

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