简介
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;[原文链接
](https://developer.aliyun.com/...，未经容许不得转载。