何时在 Java 中使用 AtomicReference？
Posted
技术标签:
【中文标题】何时在 Java 中使用 AtomicReference？【英文标题】：When to use AtomicReference in Java? 【发布时间】：2011-04-27 05:24:44 【问题描述】：我们什么时候使用AtomicReference？
是否需要在所有多线程程序中创建对象？
提供一个应该使用 AtomicReference 的简单示例。
【问题讨论】：
【参考方案1】：这是 AtomicReference 的用例：
考虑这个充当数字范围的类，并使用单独的 AtmomicInteger 变量来维护数字的下限和上限。
public class NumberRange
// INVARIANT: lower <= upper
private final AtomicInteger lower = new AtomicInteger(0);
private final AtomicInteger upper = new AtomicInteger(0);
public void setLower(int i)
// Warning -- unsafe check-then-act
if (i > upper.get())
throw new IllegalArgumentException(
"can't set lower to " + i + " > upper");
lower.set(i);
public void setUpper(int i)
// Warning -- unsafe check-then-act
if (i < lower.get())
throw new IllegalArgumentException(
"can't set upper to " + i + " < lower");
upper.set(i);
public boolean isInRange(int i)
return (i >= lower.get() && i <= upper.get());
setLower 和 setUpper 都是 check-then-act 序列，但它们没有使用足够的锁定来使其具有原子性。如果数字范围为 (0, 10)，并且一个线程调用 setLower(5) 而另一个线程调用 setUpper(4)，则在一些不幸的时机下，两者都将通过设置器中的检查，并且将应用这两个修改。结果是范围现在保持 (5, 4) 无效状态。因此，虽然底层 AtomicIntegers 是线程安全的，但复合类不是。这可以通过使用 AtomicReference 而不是使用单个 AtomicIntegers 作为上限和下限来解决。
public class CasNumberRange
// Immutable
private static class IntPair
final int lower; // Invariant: lower <= upper
final int upper;
private IntPair(int lower, int upper)
this.lower = lower;
this.upper = upper;
private final AtomicReference<IntPair> values =
new AtomicReference<IntPair>(new IntPair(0, 0));
public int getLower()
return values.get().lower;
public void setLower(int lower)
while (true)
IntPair oldv = values.get();
if (lower > oldv.upper)
throw new IllegalArgumentException(
"Can't set lower to " + lower + " > upper");
IntPair newv = new IntPair(lower, oldv.upper);
if (values.compareAndSet(oldv, newv))
return;
public int getUpper()
return values.get().upper;
public void setUpper(int upper)
while (true)
IntPair oldv = values.get();
if (upper < oldv.lower)
throw new IllegalArgumentException(
"Can't set upper to " + upper + " < lower");
IntPair newv = new IntPair(oldv.lower, upper);
if (values.compareAndSet(oldv, newv))
return;
【讨论】：
这篇文章与你的回答类似，但更深入地探讨了更复杂的事情。这真有趣！ ibm.com/developerworks/java/library/j-jtp04186 嗨！这个链接坏了，你还能找到这篇文章的链接吗？ @LppEdd【参考方案2】：原子引用应该用于需要对引用执行简单原子（即thread-safe，非平凡）操作的设置中，基于监视器的同步不适合。假设您要检查是否仅当对象的状态保持上次检查时的特定字段：
AtomicReference<Object> cache = new AtomicReference<Object>();
Object cachedValue = new Object();
cache.set(cachedValue);
//... time passes ...
Object cachedValueToUpdate = cache.get();
//... do some work to transform cachedValueToUpdate into a new version
Object newValue = someFunctionOfOld(cachedValueToUpdate);
boolean success = cache.compareAndSet(cachedValue,cachedValueToUpdate);
由于原子引用语义，即使cache 对象在线程之间共享，您也可以这样做，而无需使用synchronized。一般来说，除非您知道自己在做什么，否则最好使用同步器或java.util.concurrent 框架而不是裸露的Atomic*。
两个优秀的死树参考将向您介绍这个主题：
Herlihy's excellent Art of Multiprocessor Programming Java Concurrency in Practice请注意（我不知道这是否一直是真的）reference 赋值（即=）本身是原子的（更新 primitive 64 位类型像 long 或 double 可能不是原子的；但更新 reference 始终是原子的，即使它是 64 位的）无需显式使用 Atomic*。
请参阅Java Language Specification 3ed, Section 17.7。
【讨论】：
如果我错了，请纠正我，但似乎需要这个的关键是因为你需要做一个“compareAndSet”。如果我需要做的只是设置，我根本不需要 AtomicObject，因为引用更新本身是原子的？ @veggen Java 中的函数参数在函数本身之前被评估，因此在这种情况下内联没有任何区别。是的，它是安全的。 @sMoZely 没错，但如果你不使用AtomicReference，你应该标记变量volatile，因为虽然runtime保证引用分配是原子的， 编译器可以在变量没有被其他线程修改的假设下执行优化。
最后一行不应该是boolean success = cache.compareAndSet(cachedValueToUpdate, newValue);吗？
@haikalpribadi 是的，我很确定你是对的。 newValue 被扔掉了。放入缓存中的值是从缓存中取出的值，cachedValueToUpdate。令人着迷的是，它花了 10 年时间和 236 次投票才找到。【参考方案3】：
我不会多说。我尊敬的朋友们已经提供了宝贵的意见。 本博客最后的完整运行代码应该可以消除任何混淆。这是一个多线程场景下的电影座位预订小程序。
一些重要的基本事实如下。 1> 不同的线程只能争用堆空间中的实例和静态成员变量。 2> 易失性读取或写入完全是原子的并且序列化/发生在之前并且仅从内存中完成。通过这样说，我的意思是任何读取都将遵循内存中的先前写入。并且任何写入都将遵循先前从内存中读取的内容。因此，任何使用 volatile 的线程都将始终看到最新的值。 AtomicReference 使用了 volatile 的这个属性。
以下是 AtomicReference 的部分源代码。 AtomicReference 指的是对象引用。此引用是 AtomicReference 实例中的 volatile 成员变量，如下所示。
private volatile V value;
get() 只返回变量的最新值（就像 volatiles 以“发生在之前”的方式所做的那样）。
public final V get()
Following是AtomicReference最重要的方法。
public final boolean compareAndSet(V expect, V update)
return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
compareAndSet(expect,update) 方法调用 Java 的 unsafe 类的 compareAndSwapObject() 方法。这个不安全的方法调用调用了本地调用，它调用了一条到处理器的指令。 “期望”和“更新”每个都引用一个对象。
当且仅当 AtomicReference 实例成员变量“value”引用了“expect”引用的同一个对象时，“update”现在分配给该实例变量，并返回“true”。否则，返回 false。整个事情是原子完成的。没有其他线程可以在两者之间进行拦截。 由于这是单处理器操作（现代计算机架构的魔力），它通常比使用同步块更快。但请记住，当需要以原子方式更新多个变量时，AtomicReference 将无济于事。
我想添加一个完整的运行代码，可以在 eclipse 中运行。它会清除许多混乱。这里有 22 个用户（MyTh 线程）试图预订 20 个座位。以下是代码 sn -p 后跟完整代码。
代码 sn-p，其中 22 个用户尝试预订 20 个座位。
for (int i = 0; i < 20; i++) // 20 seats
seats.add(new AtomicReference<Integer>());
Thread[] ths = new Thread[22];// 22 users
for (int i = 0; i < ths.length; i++)
ths[i] = new MyTh(seats, i);
ths[i].start();
以下是完整的运行代码。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public class Solution
static List<AtomicReference<Integer>> seats;// Movie seats numbered as per
// list index
public static void main(String[] args) throws InterruptedException
// TODO Auto-generated method stub
seats = new ArrayList<>();
for (int i = 0; i < 20; i++) // 20 seats
seats.add(new AtomicReference<Integer>());
Thread[] ths = new Thread[22];// 22 users
for (int i = 0; i < ths.length; i++)
ths[i] = new MyTh(seats, i);
ths[i].start();
for (Thread t : ths)
t.join();
for (AtomicReference<Integer> seat : seats)
System.out.print(" " + seat.get());
/**
* id is the id of the user
*
* @author sankbane
*
*/
static class MyTh extends Thread // each thread is a user
static AtomicInteger full = new AtomicInteger(0);
List<AtomicReference<Integer>> l;//seats
int id;//id of the users
int seats;
public MyTh(List<AtomicReference<Integer>> list, int userId)
l = list;
this.id = userId;
seats = list.size();
@Override
public void run()
boolean reserved = false;
try
while (!reserved && full.get() < seats)
Thread.sleep(50);
int r = ThreadLocalRandom.current().nextInt(0, seats);// excludes
// seats
//
AtomicReference<Integer> el = l.get(r);
reserved = el.compareAndSet(null, id);// null means no user
// has reserved this
// seat
if (reserved)
full.getAndIncrement();
if (!reserved && full.get() == seats)
System.out.println("user " + id + " did not get a seat");
catch (InterruptedException ie)
// log it
【讨论】：
【参考方案4】：这是一个非常简单的用例，与线程安全无关。
要在 lambda 调用之间共享对象，AtomicReference 是一个选项：
public void doSomethingUsingLambdas()
AtomicReference<YourObject> yourObjectRef = new AtomicReference<>();
soSomethingThatTakesALambda(() ->
yourObjectRef.set(youObject);
);
soSomethingElseThatTakesALambda(() ->
YourObject yourObject = yourObjectRef.get();
);
我并不是说这是一个好的设计或任何东西（这只是一个简单的例子），但如果您有需要在 lambda 调用之间共享对象的情况，AtomicReference 是一个选项。
事实上，您可以使用任何包含引用的对象，甚至是只有一项的集合。但是，AtomicReference 非常适合。
【讨论】：
【参考方案5】：我们什么时候使用 AtomicReference？
AtomicReference 是在不使用同步的情况下以原子方式更新变量值的灵活方式。
AtomicReference 支持对单个变量进行无锁线程安全编程。
有多种方法可以通过高级concurrent API 实现线程安全。原子变量是多个选项之一。
Lock 对象支持可简化许多并发应用程序的锁定习惯用法。
Executors 定义了一个用于启动和管理线程的高级 API。 java.util.concurrent 提供的 Executor 实现提供了适合大规模应用的线程池管理。
并发集合可以更轻松地管理大型数据集合，并且可以大大减少同步需求。
原子变量具有最小化同步并有助于避免内存一致性错误的功能。
提供一个应该使用 AtomicReference 的简单示例。
带有AtomicReference的示例代码：
String initialReference = "value 1";
AtomicReference<String> someRef =
new AtomicReference<String>(initialReference);
String newReference = "value 2";
boolean exchanged = someRef.compareAndSet(initialReference, newReference);
System.out.println("exchanged: " + exchanged);
是否需要在所有多线程程序中创建对象？
您不必在所有多线程程序中都使用AtomicReference。
如果要保护单个变量，请使用AtomicReference。如果要保护代码块，请使用其他构造，例如 Lock /synchronized 等。
【讨论】：
【参考方案6】：当您需要在多个线程之间共享和更改不可变对象的状态时，原子引用是理想的选择。这是一个超级密集的陈述，所以我会稍微分解一下。
首先，不可变对象是在构造后实际上不会更改的对象。不可变对象的方法经常返回同一类的新实例。一些示例包括 Long 和 Double 的包装类以及 String，仅举几例。 （根据在 JVM 上编程并发，不可变对象是现代并发的关键部分）。
接下来，为什么 AtomicReference 在共享该共享值方面比 volatile 对象更好。一个简单的代码示例将显示差异。
volatile String sharedValue;
static final Object lock=new Object();
void modifyString()
synchronized(lock)
sharedValue=sharedValue+"something to add";
每次你想根据它的当前值修改那个 volatile 字段引用的字符串时，你首先需要获得一个对该对象的锁定。这可以防止其他线程在此期间进入并更改新字符串连接中间的值。然后，当您的线程恢复时，您会破坏另一个线程的工作。但老实说，代码会起作用，看起来很干净，而且会让大多数人开心。
小问题。它很慢。特别是如果该锁定对象有很多争用。那是因为大多数锁需要操作系统系统调用，并且您的线程将阻塞并被上下文切换出 CPU 以便为其他进程让路。
另一种选择是使用 AtomicRefrence。
public static AtomicReference<String> shared = new AtomicReference<>();
String init="Inital Value";
shared.set(init);
//now we will modify that value
boolean success=false;
while(!success)
String prevValue=shared.get();
// do all the work you need to
String newValue=shared.get()+"lets add something";
// Compare and set
success=shared.compareAndSet(prevValue,newValue);
现在为什么这样更好？老实说，代码没有以前那么干净了。但是在 AtomicRefrence 的底层发生了一些非常重要的事情，那就是比较和交换。 使切换发生的是单个 CPU 指令，而不是操作系统调用。那是 CPU 上的一条指令。而且因为没有锁，所以在锁被执行的情况下没有上下文切换，从而节省了更多时间！
问题在于，对于 AtomicReferences，这不使用 .equals() 调用，而是使用 == 比较期望值。因此，请确保预期是从循环中返回的实际对象。
【讨论】：
您的两个示例的行为不同。您必须循环worked 才能获得相同的语义。
我认为你应该在 AtomicReference 构造函数中初始化值，否则在你调用 shared.set 之前另一个线程可能仍然会看到值 null。 （除非 shared.set 在静态初始化程序中运行。）
在你的第二个例子中，你应该从 Java 8 开始使用类似的东西： shared.updateAndGet( (x) -> (x+"lets add something")); ...这将重复调用 .compareAndSet 直到它工作。这相当于总是会成功的同步块。您需要确保传入的 lambda 没有副作用，因为它可能会被多次调用。
不需要使volatile String sharedValue。同步（锁定）足以在关系之前建立发生。
“...改变不可变对象的状态”在这里是不精确的，部分原因是你不能改变不可变对象的状态。该示例演示了将引用从一个不可变对象实例更改为不同的对象实例。我意识到这很迂腐，但考虑到 Thread 逻辑的混乱程度，我认为值得强调一下。【参考方案7】：
另一个简单的例子是在会话对象中进行安全线程修改。
public PlayerScore getHighScore()
ServletContext ctx = getServletConfig().getServletContext();
AtomicReference<PlayerScore> holder
= (AtomicReference<PlayerScore>) ctx.getAttribute("highScore");
return holder.get();
public void updateHighScore(PlayerScore newScore)
ServletContext ctx = getServletConfig().getServletContext();
AtomicReference<PlayerScore> holder
= (AtomicReference<PlayerScore>) ctx.getAttribute("highScore");
while (true)
HighScore old = holder.get();
if (old.score >= newScore.score)
break;
else if (holder.compareAndSet(old, newScore))
break;
来源：http://www.ibm.com/developerworks/library/j-jtp09238/index.html
【讨论】：
【参考方案8】：您可以在应用乐观锁时使用 AtomicReference。您有一个共享对象，并且想要从多个线程中更改它。
-
您可以创建共享对象的副本
修改共享对象
您需要检查共享对象是否仍与以前相同 - 如果是，则使用修改后副本的引用进行更新。
因为其他线程可能已经修改了它并且/可以在这两个步骤之间进行修改。您需要在原子操作中执行此操作。这就是 AtomicReference 可以提供帮助的地方
【讨论】：
乐观锁是我一直在寻找的概念。以上是关于何时在 Java 中使用 AtomicReference？的主要内容，如果未能解决你的问题，请参考以下文章
何时在 Java 中使用 Identity 函数？ [复制]
请告诉我何时在 java 中使用 getInstance() 方法。 [关闭]
实际示例何时使用抽象类以及何时使用 Java 8 引入的接口（默认和静态方法）[重复]