java可见性和原子性举例分析

69次阅读
没有评论

共计 5726 个字符,预计需要花费 15 分钟才能阅读完成。

这篇文章主要讲解了“java 可见性和原子性举例分析”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着丸趣 TV 小编的思路慢慢深入,一起来研究和学习“java 可见性和原子性举例分析”吧!

简介

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;

感谢各位的阅读,以上就是“java 可见性和原子性举例分析”的内容了,经过本文的学习后,相信大家对 java 可见性和原子性举例分析这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是丸趣 TV,丸趣 TV 小编将为大家推送更多相关知识点的文章,欢迎关注!

正文完
 
丸趣
版权声明:本站原创文章,由 丸趣 2023-08-17发表,共计5726字。
转载说明:除特殊说明外本站除技术相关以外文章皆由网络搜集发布,转载请注明出处。
评论(没有评论)