java并发编程实践学习(15)原子变量与非阻塞同步机制

近来很多关于并发算法的研究机构都聚焦在非阻塞算法上,这种算法使用低层原子化的机器指令取代锁,比如比较并交换

一、锁的劣势

当频繁发生锁的竞争时,调度与真正用于工作的开销时间的比会变得很可观。volatile变量与锁相比是更清凉的同步机制,因为他们不会引起上下文的切换和线程调度。
加锁还有其他缺点。当一个线程正在等待锁时,它不能做任何其他事情。如果一个线程在持有锁的情况下发生了延迟,如果阻塞的线程是优先级很高的线程,持有锁的线程是优先级较低的线程,那么会造成优先级倒置的风险,即使高优先级占先,他仍然需要等待锁被释放,这导致他的优先级会降至与优先级较低的线程相同的水平。

二、硬件对并发的支持

针对多处理器系统设计的处理器提供了特殊的指令,用来管理并发访问的共享数据。早期处理器具有原子化的测试并设置,获取并增加,以及交换指令,现代的处理器都具有一些形式的原子化的读-改-写指令,比如比较并交换和加载链接/存储条件。操作系统和JVM使用这些指令来实现锁和并发的数据结构。

1、比较并交换

包括IA32和、Sparc在内的大多数处理器使用的架构方案都实现了比较并交换指令(CAS)。CAS有三个操作数-内存位置V、旧的预期值A和新值B、当且仅当V符合旧预期值A时,CAS用新值B原子化的更新V的值;否则它什么都不做。
当多个线程试图调用CAS同时更新想的的变量时,其中一个会胜出,并更新变量的值,而其它都会失败,失败的线程不会被挂起;
模拟CAS操作

@ThreadSafe
public class SimulatedCAS{
    @GuardedBy("this")
    private int value;

    public synchronized int get(){
        return value;
    }

    public synchronized int compareAndSwap(int expectedValue,int new Value){
        int = oldValue = value;
        if(oldValue == value){
            value = new Value;
        }
        return oldValue;
    }

    public synchronized boolean compareAndSet(int expectedValue, int newValue){
        return (expectedValue == compareAndSwap(expectedValue,newValue));
    }
}

2、JVM对CAS的支持

在Java5.0中引入了CAS的底层支持,将int、long和对象的引用暴露给CAS操作,并且JVM把它们编译为底层硬件提供的最有效的方法。在支持CVS的平台上,运行时把它们编排成恰当的机器指令,在CAS不可用的情况下,JVM才会使用自旋锁,这些底层的JVM支持用于那些具有原子化变量的类(java.util.concurrent.atomic中的AtomicXXX),而且这些原子变量类还用于直接或间接的实现java.util.concuttent中的大部分实现。

三、原子变量类

原子变量类,提供了广义的volatile变量,以及支持原子的、条件的读-写改操作
原子变量类共有12个,分成四组:计量器、域更新器、数组以及复合变量。最常用的原子变量是计量器:AtomicInteger、AtomicLong、AtomicBoolean以及AtomicReference。它们都支持CAS,AtomicInteger和AtomicLong还支持算数运算,对于short和byte把它们的值强制转化为int;对于浮点数,使用floatToIntBits或doubleToLongBits。
原子化数组类(只有Integer、Long和Reference版本可用)它的元素可以被原子化的更新。原子数组类为数组元素提供了volatile的访问语义,这是普通数组元素没有的特性。

4.非阻塞算法

一个线程的失败或挂起不影响其他线程的失败或挂起,这样的算法被称为为阻塞算法;如果算法的每一步中都有一些线程能够继续执行,这样的算法被称为锁自由算法。在线程间使用CAS进行协调,这样的算法如果能构建正确的话,它既是非阻塞的,又是锁自由的。

1、非阻塞栈

在链式容器类中,有时你可以 不必在进行转化了而把它变为对单独链接的修改,你可以使用一个AtomicReference来表达每一个必须被原子的链接。
栈是最简单的链式数据结构:每个元素仅仅引用唯一的元素,并且每个元素值被一个元素引用。
使用Treiber算法的非阻塞栈

public class ConcurrentStack {
    AtomicReference> head = new AtomicReference>();
    public void push(E item) {
        Node newHead = new Node(item);
        Node oldHead;
        do {
            oldHead = head.get();
            newHead.next = oldHead;
        } while (!head.compareAndSet(oldHead, newHead));
    }
    public E pop() {
        Node oldHead;
        Node newHead;
        do {
            oldHead = head.get();
            if (oldHead == null) 
                return null;
            newHead = oldHead.next;
        } while (!head.compareAndSet(oldHead,newHead));
        return oldHead.item;
    }
    static class Node {
        final E item;
        Node next;
        public Node(E item) { this.item = item; }
    }
}

你可能感兴趣的:(java并发学习,java,并发,编程,线程,java并发编程实践)