（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打印，线程退出。