java安全编码指南之:可见性和原子性
文章目录
- 简介
- 不可变对象的可见性
- 保证共享变量的复合操作的原子性
- 保证多个Atomic原子类操作的原子性
- 保证方法调用链的原子性
- 读写64bits的值
简介
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进行累加操作。但是++实际上是由三个操作组成的:
- 从内存中读取i的值,并写入CPU寄存器中。
- CPU寄存器中将i值+1
- 将值写回内存中的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安全编码指南之:线程安全规则
文章目录 简介 注意线程安全方法的重写 构造函数中this的溢出 不要在类初始化的时候使用后台线程 简介 如果我们在多线程中引入了共享变量,那么我们就需要考虑一下多线程下线程安全的问题了.那么我们在编 ...
- java安全编码指南之:输入校验
文章目录 简介 在字符串标准化之后进行校验 注意不可信字符串的格式化 小心使用Runtime.exec() 正则表达式的匹配 简介 为了保证java程序的安全,任何外部用户的输入我们都认为是可能有恶意 ...
- java安全编码指南之:字符串和编码
文章目录 简介 使用变长编码的不完全字符来创建字符串 char不能表示所有的Unicode 注意Locale的使用 文件读写中的编码格式 不要将非字符数据编码为字符串 简介 字符串是我们日常编码过程中 ...
- java安全编码指南之:Mutability可变性
文章目录 简介 可变对象和不可变对象 创建mutable对象的拷贝 为mutable类创建copy方法 不要相信equals 不要直接暴露可修改的属性 public static fields应该被置 ...
- java安全编码指南之:拒绝Denial of Service
文章目录 简介 为什么会有DOS 不合理的资源使用 请求用于矢量图的SVG文件和字体文件 字符串或二进制表示的图片转换 zip炸弹 billion laughs attack hashMap中插入太多 ...
- java安全编码指南之:堆污染Heap pollution
简介 什么是堆污染呢?堆污染是指当参数化类型变量引用的对象不是该参数化类型的对象时而发生的. 我们知道在JDK5中,引入了泛型的概念,我们可以在创建集合类的时候,指定该集合类中应该存储的对象类型. 如 ...
- java安全编码指南之:异常处理
简介:异常是java程序员无法避免的一个话题,我们会有JVM自己的异常也有应用程序的异常,对于不同的异常,我们的处理原则是不是一样的呢? 一起来看看吧. 简介 异常是java程序员无法避免的一个话题, ...
- java安全编码指南之:文件和共享目录的安全性
文章目录 简介 linux下的文件基本权限 linux文件的特殊权限 Set UID 和 Set GID Sticky Bit SUID/SGID/SBIT权限设置 文件隐藏属性 特殊文件 java中 ...
- java安全编码指南之:序列化Serialization
文章目录 简介 序列化简介 注意serialVersionUID writeObject和readObject readResolve和writeReplace 不要序列化内部类 如果类中有自定义变量 ...
最新文章
- Kafka 顺序消费方案
- 5G将如何推动未来十年智能城市的发展
- python篮球-基于Python/Java的人工智能篮球训练系统的制作方法
- Ubuntu在命令行下不能够切换字母的大小写,只能输入大写字母
- 东京理科大学 计算机系,东京理科大学
- 【数据结构与算法】4.数据结构图文解析系列
- 94. Binary Tree Inorder Traversal 二叉树的中序遍历
- GitLab CI持续集成配置方案
- Qt无法用UTF-8编辑问题
- git中reset与revert的区别
- windows下使用net-snmp实现agent扩展(四)
- 2_C语言中的数据类型 (二)进制
- java.util.Collections类使用(很多秘密,网上资料亲测)
- SQLServer DBA 三十问之我答(第7题)
- TMS320C6748_PWM_ECAP
- 服务器和交换机物理连接_二层、三层及四层交换机的区别 | 小知识
- APP是怎么精确统计下载数量?
- Filament渲染引擎剖析 之 通过图元构建几何体
- 基存储卡的音乐播放器v0.2
- 软件卸载不了怎么办?快用IObit Uninstaller Pro软件卸载大师
热门文章
- 广度优先遍历算法-01寻找制高点问题
- 腾讯云安装mysql本地主机名,腾讯云服务器上安装mysql,并用navicat连接
- C++ 面向对象(二)多态 : 虚函数、多态原理、抽象类、虚函数表、继承与虚函数表
- 用Python实现双端队列
- 《MySQL实战45讲》实践篇 24-29 学习笔记 (主备篇)
- 性能优化实战|使用eBPF代替iptables优化服务网格数据面性能
- 视频质量评估的新方式:VMAF百分位数
- 音视频技术开发周刊 | 145
- Google Hangouts支持使用Firefox WebRTC
- IPv6下CDN和网络的最佳实践