How AtomicReference Works in Java

综合编程 DZone (源链)

AtomicReference is still not clear to some people, so I would like to say a few words about it and provide a GitHub link
with full-fledged running code.

AtomicReference refers to an object reference. This reference is a volatile member variable in the AtomicReference instance as below.

private volatile V value;

get() simply returns the latest value of the variable (as volatiles do in a “happens before” manner).

public final V get()
public final boolean  compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
}

The compareAndSet(expect,update) method calls the compareAndSwapObject() method of the unsafe class of Java. This method call of unsafe invokes the native call, which invokes a single instruction to the processor. “expect” and “update” each reference an object.

If and only if the AtomicReference instance member variable “value” refers to the same object is referred to by “expect”, “update” is assigned to this instance variable now, and “true” is returned. Or else, false is returned. The whole thing is done atomically. No other thread can intercept in between.

The main advantage is that we do not need to use the resource consuming synchronized keyword. As we call synchronized, the following happens.

  1. The cache and registers are flushed for the running thread, which will eventually have the monitor.

  2. We create a memory barrier, and only this thread has the monitor of the object we are synchronizing.

  3. After the synchronized block ends, the variables are written into memory.

But in the case of compareAndSet(…,…) all of the above do not happen.

I have created a very small example of a ticket booking program and posted it to GitHub. The single file application can be downloaded and run in Eclipse. It is self-explanatory, and here, I provide the snippet that will clarify what the program is trying to do.

for (int i = 0; i < 4; i++) {// 4 seats, user threads will try to reserve seats
    seats.add(new AtomicReference());
}
Thread[] ths = new Thread[8];// 8 users, each is a thread
for (int i = 0; i < ths.length; i++) {
    ths[i] = new MyTh(seats, i);
    ths[i].start();
}
//as the number of users is greater, everyone cannot reserve a seat.

Here is the GitHub link again
. Just download the single source code file, add it to some Java project in Eclipse, resolve any errors due to import- or package-related issues, and run it.

Cheers!!

DZone责编内容来自:DZone (源链) | 更多关于

阅读提示:酷辣虫无法对本内容的真实性提供任何保证,请自行验证并承担相关的风险与后果!
本站遵循[CC BY-NC-SA 4.0]。如您有版权、意见投诉等问题,请通过eMail联系我们处理。
酷辣虫 » 综合编程 » How AtomicReference Works in Java

喜欢 (0)or分享给?

专业 x 专注 x 聚合 x 分享 CC BY-NC-SA 4.0

使用声明 | 英豪名录