并发包-AtomicInteger

package com.weigu.xiaochuang.concurrent;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;

/**
 * 以下的结果充分说明AtomicInteger的线程安全性.,但是究竟怎么样实现线程安全的呢?
 * 看源码
 * 并发包中的类是线程安全的:
 * 1.变量用Volidate修饰
 * 2.利用CAS机制进行乐观锁的实现
 */
public class AtomicIntegerTest {
    private static AtomicInteger atomicInteger = new AtomicInteger(0);

    private static int a = 0;

    public static void main(String[] args) throws InterruptedException {

        ordinaryIntegerTest();
        atomicIntegerTest();

        Thread.sleep(2000);
        System.out.println("a=" + a);
        System.out.println("ai=" + atomicInteger.get());

        //功能接口的实现
        atomicInteger.getAndUpdate(new IntUnaryOperator() {
            /**
             *
             * @param operand  atomicInteger.get()
             * @return
             */
            @Override
            public int applyAsInt(int operand) {
                return operand * 2;
            }
        });
        System.out.println("ai扩大为原来的2倍：" + atomicInteger.get());
        //将原来的值扩大原来3倍，在减去指定的x
        //left:就是value
        //right：就是我们指定的10
        atomicInteger.accumulateAndGet(10, new IntBinaryOperator() {
            /**
             *
             * @param left  就是当前的atomicInteger.get()
             * @param right  就是需要操作的值
             * @return
             */
            @Override
            public int applyAsInt(int left, int right) {
                return 3 * left - right;
            }
        });
        System.out.println("ai扩大为原来的3倍,在减去指定的值：" + atomicInteger.get());
    }

    private static void atomicIntegerTest() {
        /**
         * 启动10个线程去测试
         */
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        a++;
                    }

                }
            }, "线程1").start();
        }
    }

    private static void ordinaryIntegerTest() {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    atomicInteger.getAndIncrement();
                }
            }, "线程2").start();
        }
    }
}