1.4 java高并发程序设计-无锁

1. 无锁类的原理详解

CAS算法

CAS算法的过程是这样：它包含3个参数CAS(V,E,N)。V表示要更新的变量，E表示预期值，N表示新值。仅当V 值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么 都不做。最后，CAS返回当前V的真实值。CAS操作是抱着乐观的态度进行的，它总是认为自己可以成功完成 操作。当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程 不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，CAS操作即时没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。

2. 无锁类的使用

1.AtomicInteger

他是继承Number类

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest  {
    static AtomicInteger i = new AtomicInteger();

    public static class AtomicIntegerThread implements Runnable{

        @Override
        public void run() {
            for(int k=0;k<10000;k++){
                //当前值加1，返回新值
                i.incrementAndGet();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        Thread [] ts = new Thread[10];
        for (int n = 0; n<10; n++){
            ts[n] = new Thread(new AtomicIntegerThread());
        }
        for(int m=0; m<10;m++){
            ts[m].start();
        }
        for(int m=0; m<10;m++){
            ts[m].join();
        }
        System.out.println(i);
    }
}

2.AtomicReference

对引用进行修改

是一个模板类，抽象化了数据类型

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceTest {
    static AtomicReference<String>  atomicStr = new AtomicReference<String>("wangxb");

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(Math.abs((int)(Math.random()*100)));
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    /**
                     * Atomically sets the value to the given updated value
                     * if the current value {@code ==} the expected value.*/
                    if(atomicStr.compareAndSet("wangxb","zbbiex")){
                        System.out.println("Thread: "+Thread.currentThread().getId()+" change atomic value");
                    }else{
                        System.out.println("Thread: "+Thread.currentThread().getId()+" is FAILED");
                    }
                }
            }).start();
        }
    }
}

 3.AtomicIntegerArray

支持无锁的数组

import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicIntegerArrayTest {
    static AtomicIntegerArray arr = new AtomicIntegerArray(10);
    public static class AtomicIntegerArrayThread implements Runnable{

        @Override
        public void run() {
            for (int i=0;i<10000;i++){
                arr.getAndIncrement(i%arr.length());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        Thread [] ts = new Thread[10];
        for (int n = 0; n<10; n++){
            ts[n] = new Thread(new AtomicIntegerArrayThread());
        }
        for(int k=0; k<10;k++){
            ts[k].start();
        }
        for(int k=0; k<10;k++){
            ts[k].join();
        }
        System.out.println(arr);
    }

}

4.AtomicIntegerFieldUpdater

让普通变量也享受原子操

public class AtomicFieldUpdaterTest {
    public static class Student{
        int i = 0;
        volatile int score;
    }
    public final static AtomicIntegerFieldUpdater scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Student.class,"score");
    static AtomicInteger allScore = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException{
        final Student stu = new Student();
        Thread[] ts = new Thread[10000];
        for(int i = 0; i < 10000; i++){
            ts[i] = new Thread(){
                public void run(){
                    if(Math.random()>0.4){
                        scoreUpdater.incrementAndGet(stu);
                        allScore.incrementAndGet();
                    }
                }
            };
            ts[i].start();
        }
        for(int i = 0; i < 10000; i++){
            ts[i].join();
        }
        System.out.println("score:    "+ stu.score);
        System.out.println("allScore: "+ allScore);

    }
}