java安全编码指南之:可见性和原子性

时间  2020-09-26
标签 java 安全 编码 指南 可见 原子 栏目 Java 繁體版
原文   原文链接

简介

java类中会定义不少变量，有类变量也有实例变量，这些变量在访问的过程当中，会遇到一些可见性和原子性的问题。这里咱们来详细了解一下怎么避免这些问题。java

不可变对象的可见性

不可变对象就是初始化以后不可以被修改的对象，那么是否是类中引入了不可变对象，全部对不可变对象的修改都立马对全部线程可见呢？git

实际上，不可变对象只能保证在多线程环境中，对象使用的安全性，并不可以保证对象的可见性。github

先来讨论一下可变性，咱们考虑下面的一个例子：数组

public final class ImmutableObject {
    private final int age;
    public ImmutableObject(int age){
        this.age=age;
    }
}

咱们定义了一个ImmutableObject对象，class是final的，而且里面的惟一字段也是final的。因此这个ImmutableObject初始化以后就不可以改变。缓存

而后咱们定义一个类来get和set这个ImmutableObject：安全

public class ObjectWithNothing {
    private ImmutableObject refObject;
    public ImmutableObject getImmutableObject(){
        return refObject;
    }
    public void setImmutableObject(int age){
        this.refObject=new ImmutableObject(age);
    }
}

上面的例子中，咱们定义了一个对不可变对象的引用refObject，而后定义了get和set方法。多线程

注意，虽然ImmutableObject这个类自己是不可变的，可是咱们对该对象的引用refObject是可变的。这就意味着咱们能够调用屡次setImmutableObject方法。

再来讨论一下可见性。app

上面的例子中，在多线程环境中，是否是每次setImmutableObject都会致使getImmutableObject返回一个新的值呢？ui

答案是否认的。this

当把源码编译以后，在编译器中生成的指令的顺序跟源码的顺序并非彻底一致的。处理器可能采用乱序或者并行的方式来执行指令（在JVM中只要程序的最终执行结果和在严格串行环境中执行结果一致，这种重排序是容许的）。而且处理器还有本地缓存，当将结果存储在本地缓存中，其余线程是没法看到结果的。除此以外缓存提交到主内存的顺序也肯能会变化。

怎么解决呢？

最简单的解决可见性的办法就是加上volatile关键字，volatile关键字可使用java内存模型的happens-before规则，从而保证volatile的变量修改对全部线程可见。

public class ObjectWithVolatile {
    private volatile ImmutableObject refObject;
    public ImmutableObject getImmutableObject(){
        return refObject;
    }
    public void setImmutableObject(int age){
        this.refObject=new ImmutableObject(age);
    }
}

另外，使用锁机制，也能够达到一样的效果：

public class ObjectWithSync {
    private  ImmutableObject refObject;
    public synchronized ImmutableObject getImmutableObject(){
        return refObject;
    }
    public synchronized void setImmutableObject(int age){
        this.refObject=new ImmutableObject(age);
    }
}

最后，咱们还可使用原子类来达到一样的效果：

public class ObjectWithAtomic {
    private final AtomicReference<ImmutableObject> refObject= new AtomicReference<>();
    public ImmutableObject getImmutableObject(){
        return refObject.get();
    }
    public void setImmutableObject(int age){
        refObject.set(new ImmutableObject(age));
    }
}

保证共享变量的复合操做的原子性

若是是共享对象，那么咱们就须要考虑在多线程环境中的原子性。若是是对共享变量的复合操做，好比：++, -- *=, /=, %=, +=, -=, <<=, >>=, >>>=, ^= 等，看起来是一个语句，但其实是多个语句的集合。

咱们须要考虑多线程下面的安全性。

考虑下面的例子：

public class CompoundOper1 {
    private int i=0;
    public int increase(){
        i++;
        return i;
    }
}

例子中咱们对int i进行累加操做。可是++其实是由三个操做组成的：

  1. 从内存中读取i的值，并写入CPU寄存器中。
  2. CPU寄存器中将i值+1
  3. 将值写回内存中的i中。

若是在单线程环境中，是没有问题的，可是在多线程环境中，由于不是原子操做，就可能会发生问题。

解决办法有不少种，第一种就是使用synchronized关键字

public synchronized int increaseSync(){
        i++;
        return i;
    }

第二种就是使用lock：

private final ReentrantLock reentrantLock=new ReentrantLock();

    public int increaseWithLock(){
        try{
            reentrantLock.lock();
            i++;
            return i;
        }finally {
            reentrantLock.unlock();
        }
    }

第三种就是使用Atomic原子类：

private AtomicInteger atomicInteger=new AtomicInteger(0);

    public int increaseWithAtomic(){
        return atomicInteger.incrementAndGet();
    }

保证多个Atomic原子类操做的原子性

若是一个方法使用了多个原子类的操做，虽然单个原子操做是原子性的，可是组合起来就不必定了。

咱们看一个例子：

public class CompoundAtomic {
    private AtomicInteger atomicInteger1=new AtomicInteger(0);
    private AtomicInteger atomicInteger2=new AtomicInteger(0);

    public void update(){
        atomicInteger1.set(20);
        atomicInteger2.set(10);
    }

    public int get() {
        return atomicInteger1.get()+atomicInteger2.get();
    }
}

上面的例子中，咱们定义了两个AtomicInteger，而且分别在update和get操做中对两个AtomicInteger进行操做。

虽然AtomicInteger是原子性的，可是两个不一样的AtomicInteger合并起来就不是了。在多线程操做的过程当中可能会遇到问题。

一样的，咱们可使用同步机制或者锁来保证数据的一致性。

保证方法调用链的原子性

若是咱们要建立一个对象的实例，而这个对象的实例是经过链式调用来建立的。那么咱们须要保证链式调用的原子性。

考虑下面的一个例子：

public class ChainedMethod {
    private int age=0;
    private String name="";
    private String adress="";

    public ChainedMethod setAdress(String adress) {
        this.adress = adress;
        return this;
    }

    public ChainedMethod setAge(int age) {
        this.age = age;
        return this;
    }

    public ChainedMethod setName(String name) {
        this.name = name;
        return this;
    }
}

很简单的一个对象，咱们定义了三个属性，每次set都会返回对this的引用。

咱们看下在多线程环境下面怎么调用：

ChainedMethod chainedMethod= new ChainedMethod();
        Thread t1 = new Thread(() -> chainedMethod.setAge(1).setAdress("www.flydean.com1").setName("name1"));
        t1.start();

        Thread t2 = new Thread(() -> chainedMethod.setAge(2).setAdress("www.flydean.com2").setName("name2"));
        t2.start();

由于在多线程环境下，上面的set方法可能会出现混乱的状况。

怎么解决呢？咱们能够先建立一个本地的副本，这个副本由于是本地访问的，因此是线程安全的，最后将副本拷贝给新建立的实例对象。

主要的代码是下面样子的：

public class ChainedMethodWithBuilder {
    private int age=0;
    private String name="";
    private String adress="";

    public ChainedMethodWithBuilder(Builder builder){
        this.adress=builder.adress;
        this.age=builder.age;
        this.name=builder.name;
    }

    public static class Builder{
        private int age=0;
        private String name="";
        private String adress="";

        public static Builder newInstance(){
            return new Builder();
        }
        private Builder() {}

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        public Builder setAdress(String adress) {
            this.adress = adress;
            return this;
        }

        public ChainedMethodWithBuilder build(){
            return new ChainedMethodWithBuilder(this);
        }
    }

咱们看下怎么调用：

final ChainedMethodWithBuilder[] builder = new ChainedMethodWithBuilder[1];
        Thread t1 = new Thread(() -> {
            builder[0] =ChainedMethodWithBuilder.Builder.newInstance()
                .setAge(1).setAdress("www.flydean.com1").setName("name1")
                .build();});
        t1.start();

        Thread t2 = new Thread(() ->{
            builder[0] =ChainedMethodWithBuilder.Builder.newInstance()
                .setAge(1).setAdress("www.flydean.com1").setName("name1")
                .build();});
        t2.start();

由于lambda表达式中使用的变量必须是final或者final等效的，因此咱们须要构建一个final的数组。

读写64bits的值

在java中，64bits的long和double是被当成两个32bits来对待的。

因此一个64bits的操做被分红了两个32bits的操做。从而致使了原子性问题。

考虑下面的代码：

public class LongUsage {
    private long i =0;

    public void setLong(long i){
        this.i=i;
    }
    public void printLong(){
        System.out.println("i="+i);
    }
}

由于long的读写是分红两部分进行的，若是在多线程的环境中屡次调用setLong和printLong的方法，就有可能会出现问题。

解决办法本简单，将long或者double变量定义为volatile便可。

private volatile long i = 0;

本文的代码：

learn-java-base-9-to-20/tree/master/security

本文已收录于 http://www.flydean.com/java-security-code-line-visibility-atomicity/

最通俗的解读，最深入的干货，最简洁的教程，众多你不知道的小技巧等你来发现！

欢迎关注个人公众号:「程序那些事」,懂技术，更懂你！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程