java多线程之-CAS无锁-常见API
1.背景
这一节,就是学习常用的cas对象与api
.....
2.原子整数
直接看代码吧,或者看API文档
2.1.AtomicInteger的API演示
package com.ldp.demo06Atomic; import java.util.concurrent.atomic.AtomicInteger; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/16 9:15 * @description <p> * 原子整数 * JUC 并发包提供了： * AtomicBoolean * AtomicInteger * AtomicLong * </p> */ public class Test01 { public static void main(String[] args) { AtomicInteger i = new AtomicInteger(10); // 1. System.out.println("i=" + i.get() + ",执行i.getAndIncrement(),结果为:" + i.getAndIncrement() + ",实际i=" + i.get()); System.out.println("i=" + i.get() + ",执行i.incrementAndGet(),结果为:" + i.incrementAndGet() + ",实际i=" + i.get()); // 2. System.out.println("i=" + i.get() + ",执行i.getAndDecrement(),结果为:" + i.getAndDecrement() + ",实际i=" + i.get()); System.out.println("i=" + i.get() + ",执行i.decrementAndGet(),结果为:" + i.decrementAndGet() + ",实际i=" + i.get()); // 3. System.out.println("i=" + i.get() + ",执行i.getAndAdd(10),结果为:" + i.getAndAdd(10) + ",实际i=" + i.get()); System.out.println("i=" + i.get() + ",执行i.addAndGet(10),结果为:" + i.addAndGet(10) + ",实际i=" + i.get()); //4. P表示i的值 System.out.println("i=" + i.get() + ",执行i.getAndUpdate(p -> p - 2),结果为:" + i.getAndUpdate(p -> p - 2) + ",实际i=" + i.get()); System.out.println("i=" + i.get() + ",执行i.updateAndGet(p -> p - 2),结果为:" + i.updateAndGet(p -> p - 2) + ",实际i=" + i.get()); //5. P表示原来的值i , X表示修改的值10 System.out.println("i=" + i.get() + ",执行i.getAndAccumulate(10, (p, x) -> p + x),结果为:" + i.getAndAccumulate(10, (p, x) -> p + x) + ",实际i=" + i.get()); System.out.println("i=" + i.get() + ",执行i.accumulateAndGet(10, (p, x) -> p + x),结果为:" + i.accumulateAndGet(10, (p, x) -> p + x) + ",实际i=" + i.get()); /** * 测试执行结果 * i=10,执行i.getAndIncrement(),结果为:10,实际i=11 * i=11,执行i.incrementAndGet(),结果为:12,实际i=12 * i=12,执行i.getAndDecrement(),结果为:12,实际i=11 * i=11,执行i.decrementAndGet(),结果为:10,实际i=10 * i=10,执行i.getAndAdd(10),结果为:10,实际i=20 * i=20,执行i.addAndGet(10),结果为:30,实际i=30 * i=30,执行i.getAndUpdate(p -> p - 2),结果为:30,实际i=28 * i=28,执行i.updateAndGet(p -> p - 2),结果为:26,实际i=26 * i=26,执行i.getAndAccumulate(10, (p, x) -> p + x),结果为:26,实际i=36 * i=36,执行i.accumulateAndGet(10, (p, x) -> p + x),结果为:46,实际i=46 */ } }
3.原子引用
2.2.AtomicReference的API演示
package com.ldp.demo06Atomic; import org.junit.Test; import java.math.BigDecimal; import java.util.concurrent.atomic.AtomicReference; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/16 9:42 * @description <p> * 原子引用 * 为什么需要原子引用类型？ * AtomicReference * AtomicMarkableReference * AtomicStampedReference * <p> * Stamp:标记印记 * </p> */ public class Test02 { @Test public void test01AtomicReference() { AtomicReference<BigDecimal> ref = new AtomicReference<>(new BigDecimal("3.14")); while (true) { BigDecimal prev = ref.get(); BigDecimal next = prev.add(new BigDecimal("0.2")); boolean b = ref.compareAndSet(prev, next); if (b) { System.out.println("修改成功,ref=" + ref.get()); break; } } } }
2.3.ABA问题与解决
package com.ldp.demo06Atomic; import com.common.MyThreadUtil; import java.util.concurrent.atomic.AtomicReference; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 8:14 * @description */ public class Test03ABA { private static AtomicReference<String> ref = new AtomicReference<>("A"); /** * ABA问题与解决 * 代码执行结果: * A修改为B-->true * B修改为A-->true * A修改为C-->true * * @param args */ public static void main(String[] args) { String prev = ref.get(); new Thread(() -> { // A 修改为B System.out.println("A修改为B-->" + ref.compareAndSet(ref.get(), "B")); // B修改为A System.out.println("B修改为A-->" + ref.compareAndSet(ref.get(), "A")); }, "ABA").start(); MyThreadUtil.sleep(1); // A修改为C System.out.println("A修改为C-->" + ref.compareAndSet(prev, "C")); } }
2.4.AtomicStampedReference解决ABA问题
package com.ldp.demo06Atomic; import com.common.MyThreadUtil; import java.util.concurrent.atomic.AtomicStampedReference; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 8:14 * @description */ public class Test03ABAStamped { private static AtomicStampedReference<String> ref = new AtomicStampedReference<String>("A", 1); /** * ABA问题解决思路 * <p> * 主线程仅能判断出共享变量的值与最初值 A 是否相同，不知到从 A 改为 B 又 改回 A 的情况 * 如果主线程希望：只要有其它线程【修改了】共享变量，那么自己的 cas 就算失败， * 这时，需要比较值和版本号 * <p> * 代码执行结果: * A修改为B-->true * B修改为A-->true * A修改为C-->false * * @param args */ public static void main(String[] args) { String prev = ref.getReference(); int stamp = ref.getStamp(); new Thread(() -> { // A 修改为B System.out.println("A修改为B-->" + ref.compareAndSet(ref.getReference(), "B", ref.getStamp(), ref.getStamp() + 1)); // B修改为A System.out.println("B修改为A-->" + ref.compareAndSet(ref.getReference(), "A", ref.getStamp(), ref.getStamp() + 1)); }, "ABA").start(); MyThreadUtil.sleep(1); // A修改为C System.out.println("A修改为C-->" + ref.compareAndSet(prev, "C", stamp, stamp + 1)); } }
View Code
2.5.AtomicMarkableReference解决ABA问题
package com.ldp.demo06Atomic; import com.common.MyThreadUtil; import java.util.concurrent.atomic.AtomicMarkableReference; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 8:14 * @description */ public class Test03Markable { private static AtomicMarkableReference<String> ref = new AtomicMarkableReference<>("A", true); /** * ABA问题与解决 * 代码执行结果: * marked-1=true * A修改为B-->true * marked-2=false * B修改为A-->true * marked-3=true * A修改为C-->true * marked-4=false * 有时候，并不关心引用变量更改了几次，只是关心是否更改过，所以就有了AtomicMarkableReference * * @param args */ public static void main(String[] args) { String prev = ref.getReference(); System.out.println("marked-1=" + ref.isMarked()); new Thread(() -> { // A 修改为B System.out.println("A修改为B-->" + ref.compareAndSet(ref.getReference(), "B", true, false)); System.out.println("marked-2=" + ref.isMarked()); // B修改为A System.out.println("B修改为A-->" + ref.compareAndSet(ref.getReference(), "A", false, true)); }, "ABA").start(); MyThreadUtil.sleep(1); System.out.println("marked-3=" + ref.isMarked()); // A修改为C System.out.println("A修改为C-->" + ref.compareAndSet(prev, "C", true, false)); System.out.println("marked-4=" + ref.isMarked()); } }
4.原子数组
package com.ldp.demo06Atomic; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.atomic.AtomicIntegerArray; import java.util.function.BiConsumer; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 8:55 * @description <p> * 原子数组 * AtomicIntegerArray * AtomicLongArray * AtomicReferenceArray * </p> */ public class Test04Array { /** * 测试自定义的数组 * int[10] 存在线程不安全 */ @Test public void test01() throws InterruptedException { myArray(() -> new int[10], (array) -> array.length, (array, index) -> array[index]++, (array) -> System.out.println(Arrays.toString(array))); } /** * 测试自定义的数组 * AtomicIntegerArray 线程安全 */ @Test public void test02() throws InterruptedException { myArray( () -> new AtomicIntegerArray(10), (array) -> array.length(), (array, index) -> array.getAndIncrement(index), array -> System.out.println(array) ); } /** * @param supplierArray 提供一个数组 * @param functionLength 获取数组长度 * @param addArray 数组元素自增1 * @param printArray 打印数组 * @param <T> 数组的泛型 */ public <T> void myArray(Supplier<T> supplierArray, Function<T, Integer> functionLength, BiConsumer<T, Integer> addArray, Consumer<T> printArray ) throws InterruptedException { // 定义一个放线程的集合 List<Thread> list = new ArrayList<>(); // 1.提供一个数组 T array = supplierArray.get(); // 2.获取数组长度的方法 Integer length = functionLength.apply(array); // 遍历数组,使用1000个线程,每个线程给每个元素加1 for (int i = 0; i < length; i++) { // 1000个线程,每个线程给每个元素加1 Thread t = new Thread(() -> { for (int j = 0; j < 10000; j++) { // 3.自增方法,传入array与下标index addArray.accept(array, j % length); } }); list.add(t); } // 启动所有线程 for (Thread thread : list) { thread.start(); } // 等待所有线程执行完 for (Thread thread : list) { thread.join(); } // 4.打印数组的方法 printArray.accept(array); } }
5.字段更新器
package com.ldp.demo06Atomic; import org.junit.Test; import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 9:56 * @description <p> * 字段更新器 * AtomicReferenceFieldUpdater * AtomicIntegerFieldUpdater * AtomicLongFieldUpdater * </p> */ public class Test05Field { private volatile int age = 18; @Test public void test01() { AtomicIntegerFieldUpdater fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Test05Field.class, "age"); // 创建Test05Field对象 Test05Field test05Field = new Test05Field(); // 将18修改为 30岁 fieldUpdater.compareAndSet(test05Field, test05Field.age, 30); System.out.println("当前年龄:" + test05Field.age); } }
6.原子累加器:LongAdder
package com.ldp.demo06Atomic; import lombok.extern.slf4j.Slf4j; import org.junit.Test; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.LongAdder; import java.util.function.Consumer; import java.util.function.Supplier; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/18 10:13 * @description */ @Slf4j public class Test06LongAdder { /** * AtomicLong 与 LongAdder 测试 * LongAdder:在多线程并发的情况下,LongAdder会明显优于AtomicLong * <p> * LongAdder的原理: * 在由线程竞争cpu时，设置多个累加单元，Therad-0 累加 Cell[0]，而 Thread-1 累加Cell[1]... * 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性能。 * <p> * 09:35:18.967 [main] -> start..... * num=10000000,耗时:172 毫秒 * num=10000000,耗时:203 毫秒 * num=10000000,耗时:187 毫秒 * num=10000000,耗时:188 毫秒 * num=10000000,耗时:171 毫秒 * 09:35:20.013 [main] -> ------------------------------ * num=10000000,耗时:157 毫秒 * num=10000000,耗时:93 毫秒 * num=10000000,耗时:63 毫秒 * num=10000000,耗时:78 毫秒 * num=10000000,耗时:78 毫秒 * 09:35:20.482 [main] -> end..... * * @throws InterruptedException */ @Test public void test01() throws InterruptedException { log.info("start....."); for (int i = 0; i < 5; i++) { methodAdd(() -> new AtomicLong(), (num) -> num.getAndIncrement()); } log.info("------------------------------"); for (int i = 0; i < 5; i++) { methodAdd(() -> new LongAdder(), (num) -> num.increment()); } log.info("end....."); } /** * 给一个数组累加 * * @param supplierNum 传入的数字 * @param addNum 数字加一 * @param <T> */ public <T> void methodAdd(Supplier<T> supplierNum, Consumer<T> addNum) throws InterruptedException { long start = System.currentTimeMillis(); List<Thread> list = new ArrayList<>(); T num = supplierNum.get(); // 3个线程 for (int i = 0; i < 100; i++) { Thread thread = new Thread(() -> { // 每个线程加 10万次 for (int j = 0; j < 100000; j++) { addNum.accept(num); } }); list.add(thread); } // 启动线程 for (Thread thread : list) { thread.start(); } // 等待线程结束 for (Thread thread : list) { thread.join(); } long end = System.currentTimeMillis(); System.out.println("num=" + num + ",耗时:" + ((end - start)) + " 毫秒"); } }
7.CAS实现自定义锁
package com.ldp.demo06Atomic; import java.util.concurrent.atomic.AtomicInteger; /** * @author 姿势帝-博客园 * @address https://www.cnblogs.com/newAndHui/ * @WeChat 851298348 * @create 02/19 9:42 * @description <p> * 利用cas的特性实现自己的锁 * </p> */ public class Test07MyCasLock { AtomicInteger lock = new AtomicInteger(0); /** * 获取锁 */ public void lock() { while (true) { if (lock.compareAndSet(0, 1)) { // 取锁成功 break; } } } /** * 释放锁 */ public void unlock() { lock.set(0); } /** * 测试自定义的锁 * 注意:自定义的锁只是练习对cas的理解,不作为生产的实现方式 * * @param args */ public static void main(String[] args) { // UnsafeAccessor. Test07MyCasLock casLock = new Test07MyCasLock(); casLock.lock(); try { System.out.println("加锁成功...."); } finally { casLock.unlock(); System.out.println("锁已经释放..."); } } }
