Java并发包原子类API使用笔记

一、Java并法包的原子类有AtomicInteger 、AtomicBoolean 、AtomicLong 、AtomicReference 、AtomicIntegerArray 、AtomicLongArray 、AtomicReferenceArray、 AtomicIntegerFieldUpdater等。
前4个的用法大同小异，引用原子类的目的是在操作计数时使用原子类无需关系线程并发产生的问题，因为它们是线程安全的类，这里记录AtomicInteger的使用方式，供自己下次使用：
1、int addAndGet（int delta）方法：以原子方式将给定值与当前值相加，可用于线程中的计数使用，（返回更新的值）。
2、int getAndAdd（int delta）：以原子方式将给定值与当前值相加，可用于线程中的计数使用，（返回以前的值）。
3、int incrementAndGet()：以原子方式将当前值加 1（返回更新的值）。
4、int getAndIncrement() ：以原子方式将当前值加 1（返回以前的值）。
5、int getAndSet(int newValue):以原子方式设置为给定值（返回旧值）。
6、boolean compareAndSet(int expect, int update) ：当计数值达到了预定值时可以将其值更新成新的值。
7、int decrementAndGet() ： 以原子方式将当前值减 1（返回更新的值）。
8、int getAndDecrement()： 以原子方式将当前值减 1（返回以前的值）。
9、get():获取当前值。
例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;


class AtomicIntegerThread implements Runnable{
    private AtomicInteger i;
    AtomicIntegerThread(AtomicInteger i){
        this.i = i;
    }
    public int getValue() {
        return i.get();
    }

    private int inCrement() {
        return i.addAndGet(1);
    }

    private boolean compareAndSet(int expect, int update){
        return i.compareAndSet(expect, update);
    }
    private int decrementAndGet(){
        return i.decrementAndGet();
    } 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //获取当前值
            int val = getValue();
            if(val == 5){
                //开始减
                val = decrementAndGet();
            }else{
                val = inCrement();
                //达到30时将值改为0
                compareAndSet(30,0);            
            }
            System.out.println(val);
        }
    }

}
public class AtomicIntegerDemo {
    public static void main(String[] args) {
        AtomicInteger integer = new AtomicInteger(10);
        AtomicIntegerThread atomicIntegerThread = new AtomicIntegerThread(integer);
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            exec.execute(atomicIntegerThread);
        }
        exec.shutdown();
    }

}

/**
 * AutomicReference例子
 */

public class AutomicReferenceDemo implements Runnable {
    public AtomicReference<User> reference = new AtomicReference<User>();
    List<User> list = new ArrayList<User>();
    {
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setName("hi"+i);
            user.setLevel(i);
            list.add(user);         
        }
    }
    AutomicReferenceDemo(int level){
        for (User user : list) {
            if(user.getLevel() == level){
                reference.set(user);

            }
        }
    }
    @Override
    public void run() {
        System.out.println("UserName is:"+reference.get().getName()+"....level is..."+ reference.get().getLevel());
        User userNew = new User();
        userNew.setName("heihei");
        userNew.setLevel(6);
        for (User user : list) {
            //比较是否与预期值一样，相同则替换成新值。
            reference.compareAndSet(user,userNew);
        }
        System.out.println("UserName is:"+reference.get().getName()+"....level is..."+ reference.get().getLevel());
    }

    public static void main(String[] args) {

        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new AutomicReferenceDemo(3));
        exec.shutdown();
    }
}
class User {
    String name;
    int level;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

}

/**
 * AtomicIntegerArray例子:
 * 输出结果为[10001, 10001, 10001, 10001, 10001]则表示线程是安全的
 */
class AtomicIntegerArrayThread implements Runnable {
    private static AtomicIntegerArray array;

    public AtomicIntegerArrayThread(AtomicIntegerArray array) {
        this.array = array;
    }

    // 不会改变数组的原始值，因为AtomicIntegerArray只是复制了一份value的值。

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            array.addAndGet(i, 1);
        }
    }

}

public class AtomicIntegerArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[] { 1, 1, 1, 1, 1 };
        AtomicIntegerArray array = new AtomicIntegerArray(arr);
        ExecutorService exec = Executors.newCachedThreadPool();
        //开启10000个线程
        for (int i = 0; i < 10000; i++) {
            exec.execute(new AtomicIntegerArrayThread(array));
        }
        System.out.println(array);
        // 操作array不会改变arr的值，因为AtomicIntegerArray只是将数组的值复制给了array。
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);         
        }
        exec.shutdown();
    }

}