Java中的13个原子操作类

于 2020-08-12 23:17:31 发布
阅读量187 收藏
点赞数
分类专栏： java并发编程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40472874/article/details/107935932
版权

当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变 量i=1，A线程更新i+1，B线程也更新i+1，经过两个线程操作之后可能i不等于3，而是等于2。
因为A和B线程在更新变量i的时候拿到的i都是1，这就是线程不安全的更新操作，通常我们会使 用synchronized来解决这个问题，synchronized会保证多线程不会同时更新变量i。
而Java从JDK 1.5开始提供了java.util.concurrent.atomic包（以下简称Atomic包），这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。 因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更 新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性（字段）。 Atomic包里的类基本都是使用Unsafe实现的包装类。

原子更新基本类型类

使用原子的方式更新基本类型，Atomic包提供了以下3个类。 ·AtomicBoolean：原子更新布尔类型（boolean类型也是转成int类型0,1再操作）。 ·AtomicInteger：原子更新整型。 ·AtomicLong：原子更新长整型。使用方法类似。

AtomicInteger常用API

1.int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果。
2.boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
3.int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。 4.void lazySet（int newValue）：最终会设置成newValue，使用lazySet设置值后，可能导致其他 线程在之后的一小段时间内还是可以读到旧的值。(该方法适用于 不需要立即让其他线程共享变量的场景，没有屏障等可以提高性能)。
5.int getAndSet（int newValue）：以原子方式设置为newValue的值，并返回旧值。

AtomicInteger类getAndIncrement源码分析

public final int getAndIncrement() {
	//调用的还是unsafe类下getAndAddInt方法,
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
    
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

AtomicInteger类示例

public class AtomicDemo {
    public static void main(String[] args) throws Exception {
    	//初始化为2
        AtomicInteger atomicInteger = new AtomicInteger(2);
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("getAndIncrement()结果：" + atomicInteger.getAndIncrement());
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("addAndGet(2)结果：" + atomicInteger.addAndGet(2));
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("getAndIncrement()结果：" + atomicInteger.getAndIncrement());
            }
        });
        Thread threadD = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("addAndGet(3)结果：" + atomicInteger.addAndGet(3));
            }
        });
        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
        Thread.sleep(2000);
        System.out.println("最终的结果：" + atomicInteger.get());
    }
}

getAndIncrement()结果：2 //先get(),再加1，返回加之前的值
getAndIncrement()结果：3
addAndGet(3)结果：7 //先加3，再返回加之后的值
addAndGet(2)结果：9
最终的结果：9

原子更新数组

1.AtomicIntegerArray：原子更新整型数组里的元素。
2.AtomicLongArray：原子更新长整型数组里的元素。
3.AtomicReferenceArray：原子更新引用类型数组里的元素。
操作类似，只拿一个作为演示。

AtomicIntegerArray常用API

1.int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。
2.boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

AtomicIntegerArray示例

public class AtomicDemo {
    public static void main(String[] args) throws Exception {
        int[] num = new int[]{1,2,3,4};
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(num);

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //下标为1的数值做自增,返回2，值为3
                System.out.println("getAndIncrement(1)结果：" + atomicIntegerArray.getAndIncrement(1));
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                //值更新为4
                System.out.println("compareAndSet(1,3,4) ：" + atomicIntegerArray.compareAndSet(1,3,4) );
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                //值加2，变为6，返回6
                System.out.println("addAndGet(1,2)()结果：" + atomicIntegerArray.addAndGet(1,2));
            }
        });
        Thread threadD = new Thread(new Runnable() {
            @Override
            public void run() {
                //返回6，自减值为5
                System.out.println("getAndIncrement(1)结果：" + atomicIntegerArray.getAndDecrement(1));
            }
        });
        threadA.start();
        threadA.join();
        threadB.start();
        threadB.join();
        threadC.start();
        threadC.join();
        threadD.start();
        Thread.sleep(2000);
        //值为5
        System.out.println("最终的结果：" + atomicIntegerArray.get(1));
        //原num数组
        System.out.println("最终的结果：" + num[1]);
    }
}
getAndIncrement(1)结果：2
compareAndSet(1,3,4) ：true
addAndGet(1,2)()结果：6
getAndIncrement(1)结果：6
最终的结果：5
最终的结果：2

需要注意的是，数组num 通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组num 。

原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需 要使用这个原子更新引用类型提供的类。
Atomic包提供了以下3个类。
1.AtomicReference：原子更新引用类型。
2.AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
3.AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，boolean initialMark）。
以上几个类提供的方法几乎一样，所以仅以AtomicReference为例进行讲解。

AtomicReference常用API

1.V getAndSet(V newValue):返回旧值，赋新值
2.boolean compareAndSet(V expectedValue, V newValue)：若期望值为expectedValue，替换为newValue

AtomicReference示例

public class AtomicDemo {
    static class User {
        private String name;
        private int old;
        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }
        public String getName() {
            return name;
        }
        public int getOld() {
            return old;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", old=" + old +
                    '}';
        }
    }

    public static void main(String[] args) throws Exception {
        //原User
        User user = new User("minxl",23);
        AtomicReference<User> atomicReference = new AtomicReference<User>();
        //赋值
        atomicReference.set(user);
        //创建新User userNew2
        User userNew2 = new User("minxl2",24);
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //比较如果期望值是user，更新为userNew2
                System.out.println("compareAndSet(user,userNew2)：" + atomicReference.compareAndSet(user,userNew2));
            }
        });
        //创建新User userNew3
        User userNew3 = new User("minxl3",25);
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                //重新赋值新userNew3,返回旧userNew2
                System.out.println("getAndSet(userNew3) ：" + atomicReference.getAndSet(userNew3));
            }
        });

        threadA.start();
        threadA.join();
        threadB.start();
        threadB.join();
        //输出最终的结果
        System.out.println("最终的结果：" + atomicReference.get().toString());
    }
}

compareAndSet(user,userNew2)：true
getAndSet(userNew3) ：User{name='minxl2', old=24}
最终的结果：User{name='minxl3', old=25}

原子更新字段类

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类，Atomic包提供 了以下3个类进行原子字段更新。 1.AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。 2.AtomicLongFieldUpdater：原子更新长整型字段的更新器。 3.AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起 来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的 ABA问题。
要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第 二步，更新类的字段（属性）必须使用public volatile修饰符。

AtomicIntegerFieldUpdater示例

public class AtomicDemo {
    static class User {
        public volatile String name;
        public volatile int old;
        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }
        public String getName() {
            return name;
        }
        public int getOld() {
            return old;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", old=" + old +
                    '}';
        }
    }

    public static void main(String[] args) throws Exception {
        AtomicIntegerFieldUpdater atomicIntegerFieldUpdater =  AtomicIntegerFieldUpdater.newUpdater(User.class,"old");
        //原User
        User user = new User("minxl",23);
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //加2岁，返回加之后的值25
                System.out.println(atomicIntegerFieldUpdater.addAndGet(user,2));
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                //自增，返回旧值
                System.out.println(atomicIntegerFieldUpdater.getAndIncrement(user));
            }
        });
        threadA.start();
        threadA.join();
        threadB.start();
        threadB.join();
        //输出最终的结果
        System.out.println("最终的结果：" + atomicIntegerFieldUpdater.get(user));
        //输出最终的结果，在原引用类型上修改
        System.out.println("最终的结果：" + user);
    }
    
25
25
最终的结果：26
最终的结果：User{name='minxl', old=26}

AtomicStampedReference示例

public class AtomicDemo {
    static class User {
        public volatile String name;
        public volatile int old;
        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }
        public String getName() {
            return name;
        }
        public int getOld() {
            return old;
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", old=" + old +
                    '}';
        }
    }

    public static void main(String[] args) throws Exception {
        //原User
        User user = new User("minxl",23);
        AtomicStampedReference atomicIntegerFieldUpdater = new  AtomicStampedReference(user,0);
        //新User2
        User user2 = new User("minxl2",24);
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                //替换user,对应的字段也替换
                System.out.println(atomicIntegerFieldUpdater.compareAndSet(user,user2,0,2));
            }
        });
        User user3 = new User("minxl3",25);
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                //替换user,对应的字段也替换
                System.out.println(atomicIntegerFieldUpdater.compareAndSet(user2,user3,2,2));
            }
        });
        threadA.start();
        threadA.join();
        threadB.start();
        threadB.join();
        //输出最终的结果
        System.out.println("最终的结果：" + atomicIntegerFieldUpdater.getReference()+"-----"+atomicIntegerFieldUpdater.getStamp());
        //输出最终的结果
        System.out.println("最终的结果：" + user);
    }
}

true
true
最终的结果：User{name='minxl3', old=25}-----2
最终的结果：User{name='minxl', old=23}
细嗅蔷薇的大老虎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值