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

43次阅读

共计 5449 个字符，预计需要花费 14 分钟才能阅读完成。

简介

java 类中会定义很多变量，有类变量也有实例变量，这些变量在拜访的过程中，会遇到一些可见性和原子性的问题。这里咱们来具体理解一下怎么防止这些问题。

不可变对象的可见性

不可变对象就是初始化之后不可能被批改的对象，那么是不是类中引入了不可变对象，所有对不可变对象的批改都立马对所有线程可见呢？

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

先来讨论一下可变性，咱们思考上面的一个例子：

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 办法。

再来讨论一下可见性。

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

答案是否定的。

当把源码编译之后，在编译器中生成的指令的程序跟源码的程序并不是完全一致的。处理器可能采纳乱序或者并行的形式来执行指令（在 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/

最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！

欢送关注我的公众号:「程序那些事」, 懂技术，更懂你！

正文完
java
发表至： java
2020-09-25
 0
关于java:elasticsearch父子文档处理join
关于java:中间件面试专题RabbitMQ高频面试问题
关于java:Hadoop-框架学习笔记之整体认知
Ｄubbo 自定义异常，你是怎么处理的？