Java 多线程之原子类

原子变量类

原子变量类基于CAS实现的,当对共享变量进行read-modify-write更新操作时,通过原子
变量类可以保障操作的原子性与可见性.对变量的read-modify-write更新操作是指当前
操作不是一个简单的赋值,而是变量的新值依赖变量的旧值,如自增操作i++.由于volatile
只能保证可见性,无法保障原子性,原子变量类内部就是借助一个Volatile变量,并且保障
了该变量的read-modify-write操作的原子性,有时把原子变量类看作增强的volatile变量

常用原子类：

package com.zz.AtomicArray.Lianxi;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 注意原子性问题主要解决元素不重复
 */
public class AtoInteger01 {
    public static void main(String[] args) {
        AtomicInteger num = new AtomicInteger(10);
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i1 = 0; i1 < 100; i1++) {
                        num.getAndIncrement();
                        System.out.println(num.get());
                    }
                }
            }).start();
        }
    }
}

======================================================================
package com.zz.AtomicArray.Lianxi;

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReference001 {
    public static AtomicReference<String> str = new AtomicReference<>("zhang");
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    str.compareAndSet("zhang", "111");
                    System.out.println(str.get());
                    System.out.println(str.compareAndSet("111", "abc"));
                }
            }
        }).start();
        Thread.sleep(1000);
        System.out.println(str.get());
    }
}

-----------------------------------------------------------------
package com.zz.AtomicArray.Lianxi;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicArray001 {
    public static AtomicIntegerArray list = new AtomicIntegerArray(10);
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    list.set(i % 10, 10);
                    System.out.println(list.getAndIncrement(2));
                    System.out.println(list.get(3));
                }
            }
        }).start();
    }
}

------------------------------------------------------

package com.zz.AtomicIntegerFiledUpfate;

public class Zi {
    private int age;
    volatile int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Zi{" +
                "age=" + age +
                ", count=" + count +
                '}';
    }
}
-------------------------------------------------
package com.zz.AtomicIntegerFiledUpfate;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class Thread02 extends Thread{

    private Zi user;

    public Thread02(Zi user){
        this.user = user;
    }

    private AtomicIntegerFieldUpdater<Zi> use = AtomicIntegerFieldUpdater.newUpdater(Zi.class, "count");

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(use.getAndIncrement(user));
        }
    }
}