Java之多线程 Atomic（原子的）

一、何谓Atomic？

Atomic一词跟原子有点关系，后者曾被人认为是最小物质的单位。计算机中的Atomic是指不能分割成若干部分的意思。如果一段代码被认为是Atomic，则表示这段代码在执行过程中，是不能被中断的。通常来说，原子指令由硬件提供，供软件来实现原子方法（某个线程进入该方法后，就不会被中断，直到其执行完成）

在x86 平台上，CPU提供了在指令执行期间对总线加锁的手段。CPU芯片上有一条引线#HLOCK pin，如果汇编语言的程序中在一条指令前面加上前缀"LOCK"，经过汇编以后的机器代码就使CPU在执行这条指令的时候把#HLOCK pin的电位拉低，持续到这条指令结束时放开，从而把总线锁住，这样同一总线上别的CPU就暂时不能通过总线访问内存了，保证了这条指令在多处理器环境中的原子性。

二、JDK1.5的原子包：java.util.concurrent.atomic

这个包里面提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。其中的类可以分成4组

AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
AtomicIntegerArray，AtomicLongArray
AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
AtomicMarkableReference，AtomicStampedReference，AtomicReferenceArray

Atomic类的作用

使得让对单一数据的操作，实现了原子化
使用Atomic类构建复杂的，无需阻塞的代码
- 访问对2个或2个以上的atomic变量（或者对单个atomic变量进行2次或2次以上的操作）通常认为是需要同步的，以达到让这些操作能被作为一个原子单元。

2.1 AtomicBoolean , AtomicInteger, AtomicLong, AtomicReference

这四种基本类型用来处理布尔，整数，长整数，对象四种数据。

构造函数（两个构造函数）
- 默认的构造函数：初始化的数据分别是false，0，0，null
- 带参构造函数：参数为初始化的数据
set( )和get( )方法：可以原子地设定和获取atomic的数据。类似于volatile，保证数据会在主存中设置或读取
getAndSet( )方法
- 原子的将变量设定为新数据，同时返回先前的旧数据
- 其本质是get( )操作，然后做set( )操作。尽管这2个操作都是atomic，但是他们合并在一起的时候，就不是atomic。在Java的源程序的级别上，如果不依赖synchronized的机制来完成这个工作，是不可能的。只有依靠native方法才可以。
compareAndSet( ) 和weakCompareAndSet( )方法
- 这两个方法都是conditional modifier方法。这2个方法接受2个参数，一个是期望数据(expected)，一个是新数据(new)；如果atomic里面的数据和期望数据一致，则将新数据设定给atomic的数据，返回true，表明成功；否则就不设定，并返回false。
对于AtomicInteger、AtomicLong还提供了一些特别的方法。getAndIncrement( )、incrementAndGet( )、getAndDecrement( )、decrementAndGet ( )、addAndGet( )、getAndAdd( )以实现一些加法，减法原子操作。(注意 --i、++i不是原子操作，其中包含有3个操作步骤：第一步，读取i；第二步，加1或减1；第三步：写回内存)

2.1.1 1个例子-使用AtomicReference创建线程安全的堆栈

public class LinkedStack<T> {

    private AtomicReference<Node<T>> stacks = new AtomicReference<Node<T>>();

    public T push(T e) {
        Node<T> oldNode, newNode;
        while (true) { //这里的处理非常的特别，也是必须如此的。
            oldNode = stacks.get();
            newNode = new Node<T>(e, oldNode);
            if (stacks.compareAndSet(oldNode, newNode)) {
                return e;
            }
        }
    }
    
    public T pop() {
        Node<T> oldNode, newNode;
        while (true) {
            oldNode = stacks.get();
            newNode = oldNode.next;
            if (stacks.compareAndSet(oldNode, newNode)) {
                return oldNode.object;
            }
        }
    }

    private static final class Node<T> {
        private T object;
        
        private Node<T> next;

        private Node(T object, Node<T> next) {
            this.object = object;
            this.next = next;
        }
    }
}

2.1.2 几个问题

Q1： compareAndSet和weakCompareAndSet的区别？

A1：有人认为这是个坑，因为这2个方法其中的内容是一模一样的。疑惑ing（环境JDK1.6.0_20_b02）

Q2：volatile boolean和AtomicBoolean的区别？

Q3：volatile int和AtomicInteger的区别？

Q4：LazySet()和Set()的区别？

三、Atomic举例

3.1 原子量实现的计数器

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {

    private AtomicInteger value = new AtomicInteger();

    public int getValue() {
        return value.get();
    }

    public int increase() {
        return value.incrementAndGet();// 内部使用死循环for(;;)调用compareAndSet(current, next)
        //        return value.getAndIncrement();
    }

    public int increase(int i) {
        return value.addAndGet(i);// 内部使用死循环for(;;)调用compareAndSet(current, next)
        //        return value.getAndAdd(i);
    }

    public int decrease() {
        return value.decrementAndGet();// 内部使用死循环for(;;)调用compareAndSet(current, next)
        //        return value.getAndDecrement();
    }

    public int decrease(int i) {
        return value.addAndGet(-i);// 内部使用死循环for(;;)调用compareAndSet(current, next)
        //        return value.addAndGet(-i);
    }

    public static void main(String[] args) {
        final AtomicCounter counter = new AtomicCounter();
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(counter.increase());
                }
            });
        }
        service.shutdown();
    }
}

3.2 原子量实现的银行取款

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
public class Account {

    private AtomicLong balance;

    public Account(long money) {
        balance = new AtomicLong(money);
        System.out.println("Total Money:" + balance);
    }

    public void deposit(long money) {
        balance.addAndGet(money);
    }

    public void withdraw(long money) {
        for (; ; ) {//保证即时同一时间有人也在取款也可以再次尝试取款，如果不需要并发尝试取款，可以去掉这句
            long oldValue = balance.get();
            if (oldValue < money) {
                System.out.println(Thread.currentThread().getName() + " 余额不足！ 余额：" + balance);
                break;
            }
            try {Thread.sleep(new Random().nextInt(1000));} catch (Exception e) { }// 模拟取款时间
            if (balance.compareAndSet(oldValue, oldValue - money)) {
                System.out.println(Thread.currentThread().getName() + " 取款 " + money + " 成功！ 余额：" + balance);
                break;
            }
            System.out.println(Thread.currentThread().getName() + " 遇到并发，再次尝试取款！");
        }
    }

    public static void main(String[] args) {
        final Account account = new Account(1000);
        ExecutorService pool = Executors.newCachedThreadPool();
        int i = 0;
        while (i++ < 13) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    account.withdraw(100);
                }
            });
        }
        pool.shutdown();
    }
}

Java之多线程 Atomic（原子的）

猜你喜欢