AtomicInteger类

1.AtomicInteger类

        Atomic 关键字  这个关键字不存在
        java.util.concurrent.atomic 包路径下 定义了一些对【变量】操作的【原子类】
                - java.util.concurrent.atomic.AtomicInteger: 对int类型变量操作的【原子类】
                - java.util.concurrent.atomic.AtomicLong: 对long类型变量操作的【原子类】
                - java.util.concurrent.atomic.AtomicBoolean: 对boolean类型变量操作的【原子类】
                        他们可以保证对【变量】操作的：原子性，有序性，可见性

public class MyThread extends Thread{
    //共享变量
    //static int a = 0;
    static AtomicInteger a = new AtomicInteger();   //a表示默认初始值  0

    @Override
    public void run() {
        // 任务：对共享变量a自增10万次
        for (int i = 0; i < 100000; i++) {
            a.getAndIncrement();  // 相当与a++
        }
        System.out.println("子线程执行完毕！");
    }
}




public class Tests {

    public static void main(String[] args) {

        // 创建线程对象
        MyThread myThread = new MyThread();
        // 启动线程
        myThread.start();
        // 主线程对共享变量a自增10万次
        for (int i = 0; i < 100000; i++) {
            MyThread.a.getAndIncrement();   // 相当于a++
        }

        // 暂停  保证主线程和子线程都对共享变量a自增完了10万次，在统计a的结果
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 打印最终共享变量a的值
        System.out.println("最终"+ MyThread.a);

        // 期望的结果：   最终a的值是 200000

        // 原因：两个线程对共享变量的操作 产生了 覆盖的效果

        // 解决：使用 AtomicInteger 对象来作为共享变量自增，实际结果 200000

        // 无论我们程序执行多少次，其结果总是正确的
    }
}

 

2.AtomicIntegerArray类

      - java.util.concurrent.atomic.AtomicIntegerArray：对int[]类型数组操作的【原子类】
      - java.util.concurrent.atomic.AtomicLongArray：对long[]类型数组操作的【原子类】
      - java.util.concurrent.atomic.AtomicReferenceArray：对引用数据类型数组操作的【原子类】
数组的多线程并发访问的安全性问题
AtomicIntegerArray类：表示int[]数组，操作该数组就是原子操作
演示：3000条线程都对同一个长度为1000的数组中的所有元素全部自增1

public class MyThread extends Thread{
    // 共享变量
    //int[] arr1 = new int[1000];
    static AtomicIntegerArray arr = new AtomicIntegerArray(1000);

    @Override
    public void run() {
        // 任务：对arr数组中所有元素全部自增 1
        for (int i = 0; i < arr.length(); i++) {
            arr.getAndAdd(i,1);
        }
        System.out.println("子线程执行完毕");
    }

}





public class Tests {
    public static void main(String[] args) {

        // 主线程对共享变量a自增10万次
        for (int i = 0; i < 1000; i++) {
            // 创建线程对象
            MyThread mt = new MyThread();
            // 启动线程
            mt.start();
        }
        // 暂停  保证主线程和子线程都对共享变量a自增完了10万次，在统计a的结果
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 打印最终共享变量a的值
        System.out.println(MyThread.arr);

        // 期望的结果： 数组中的每个元素最终结果为 1000

        // 实际的结果：数组中的有些元素没有完成1000的累加
        // 解决：使用AtomicIntegerArray定义共享数组对象

        // 原因：两个线程对共享变量的操作 产生了 覆盖的效果
    }