java 原子类

Java 并发包中的原子类都是基于无锁方案实现的(CAS)，相较于传统的互斥锁，无锁并没有加锁、解锁、线程切换的消耗，因此无锁解决方案的性能更好，同时无锁还能够保证线程安全。

java原子类预览

AtomicInteger 示例

package com.zhang.myjuc.a4.atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * AtomicIntegerDemo:演示AtomicInteger的基本用法，对比非原子类的线程安全问题，使用了原子类之后，不需要加锁，也可以保证线程安全。
 *
 * @author zhangxiaoxiang
 * @date 2020/08/17
 */
public class AtomicIntegerDemo implements Runnable {
    //定义一个可见性变量
    private static volatile int basicCount=0;
    //AtomicInteger的基本使用
    private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger();

    /**
     * 原子类使用方式
     */
    public void incrementAtomic() {
        //里面可以传不同的值
        ATOMIC_INTEGER.getAndAdd(1);
    }


    /**
     * 常规使用方式
     */
    public /*synchronized */void intcrementBasic(){
        basicCount++;
    }

    /**
     * 线程任务是从0到10000的累加
     */
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            incrementAtomic();
            intcrementBasic();
        }
    }
    //测试
    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerDemo atomicIntegerDemo = new AtomicIntegerDemo();
        //不要显式创建线程，请使用线程池。(这里只是简单测试)
        Thread thread = new Thread(atomicIntegerDemo);
        Thread thread2 = new Thread(atomicIntegerDemo);
        thread.start();
        thread2.start();
        thread.join();
        thread2.join();
        System.out.println("原子类的结果: "+ATOMIC_INTEGER.get());
        System.out.println("普通变量的结果(注意加synchronized与否的区别): "+basicCount);
    }
}

AtomicLong与LongAdder(LongAdderDemo:演示高并发场景下，LongAdder比AtomicLong性能好)

package com.zhang.myjuc.a4.atomic;

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

/**
 * AtomicLongDemo: 演示高并发场景下，LongAdder比AtomicLong性能好
 *
 * @author zhangxiaoxiang
 * @date 2020/08/17
 */
public class AtomicLongDemo {
    public static void main(String[] args) {
        AtomicLong counter = new AtomicLong(0);
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        //下面是监测线程池关闭
        service.shutdown();
        while (!service.isTerminated()){
        }
        long end = System.currentTimeMillis();
        System.out.println("演示高并发场景下，LongAdder比AtomicLong性能好");
        System.out.println("AtomicLong耗时: "+(end-start));
    }
    private static class Task implements Runnable{
        private AtomicLong counter;

        /**
         * 构造一个带参的任务
         * @param counter
         */
        public Task(AtomicLong counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        }
    }

}

package com.zhang.myjuc.a4.atomic;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * LongAdderDemo:演示高并发场景下，LongAdder比AtomicLong性能好
 *
 * @author zhangxiaoxiang
 * @date 2020/08/17
 */
public class LongAdderDemo {
    public static void main(String[] args) {
        LongAdder counter = new LongAdder();
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        //下面是监测线程池关闭
        service.shutdown();
        while (!service.isTerminated()){
        }
        long end = System.currentTimeMillis();
        System.out.println("演示高并发场景下，LongAdder比AtomicLong性能好");
        System.out.println("LongAdder耗时: "+(end-start));
    }
    private static class Task implements Runnable{
        private LongAdder counter;

        /**
         * 构造一个带参的任务
         * @param counter
         */
        public Task(LongAdder counter) {
            this.counter = counter;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        }
    }
}