util/concurrent/AtomicLinkedNode.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain. Use, modify, and
 * redistribute this code in any way without acknowledgement.
 */

package java.util.concurrent;
import java.util.concurrent.atomic.*;

/**
 * A linked list node supporting atomic operations on both item and
 * next fields, Used by non-blocking linked-list based classes.
 * @since 1.5
 * @author Doug Lea
 */

final class AtomicLinkedNode {
    private volatile Object item;
    private volatile AtomicLinkedNode next;

    private static final 
        AtomicReferenceFieldUpdater<AtomicLinkedNode, AtomicLinkedNode> 
        nextUpdater =
        AtomicReferenceFieldUpdater.newUpdater
        (AtomicLinkedNode.class, AtomicLinkedNode.class, "next");
    private static final 
        AtomicReferenceFieldUpdater<AtomicLinkedNode, Object> 
        itemUpdater =
        AtomicReferenceFieldUpdater.newUpdater
        (AtomicLinkedNode.class, Object.class, "item");

    AtomicLinkedNode(Object x) { item = x; }

    AtomicLinkedNode(Object x, AtomicLinkedNode n) { item = x; next = n; }

    Object getItem() {
        return item;
    }

    boolean casItem(Object cmp, Object val) {
        return itemUpdater.compareAndSet(this, cmp, val);
    }

    void setItem(Object val) {
        itemUpdater.set(this, val);
    }

    AtomicLinkedNode getNext() {
        return next;
    }

    boolean casNext(AtomicLinkedNode cmp, AtomicLinkedNode val) {
        return nextUpdater.compareAndSet(this, cmp, val);
    }

    void setNext(AtomicLinkedNode val) {
        nextUpdater.set(this, val);
    }

}
Revision:	1.5
Committed:	Wed Aug 20 14:49:25 2003 UTC (20 years, 9 months ago) by dl
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.4:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	AtomicLinkedNode now an inner class of Concurrentlinkedqueue
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain. Use, modify, and
4			* redistribute this code in any way without acknowledgement.
5			*/
6
7			package java.util.concurrent;
8			import java.util.concurrent.atomic.*;
9
10			/**
11			* A linked list node supporting atomic operations on both item and
12			* next fields, Used by non-blocking linked-list based classes.
13	dl	1.2	* @since 1.5
14			* @author Doug Lea
15	dl	1.1	*/
16
17			final class AtomicLinkedNode {
18			private volatile Object item;
19			private volatile AtomicLinkedNode next;
20
21	dl	1.4	private static final
22			AtomicReferenceFieldUpdater<AtomicLinkedNode, AtomicLinkedNode>
23			nextUpdater =
24			AtomicReferenceFieldUpdater.newUpdater
25			(AtomicLinkedNode.class, AtomicLinkedNode.class, "next");
26			private static final
27			AtomicReferenceFieldUpdater<AtomicLinkedNode, Object>
28			itemUpdater =
29			AtomicReferenceFieldUpdater.newUpdater
30			(AtomicLinkedNode.class, Object.class, "item");
31	dl	1.1
32			AtomicLinkedNode(Object x) { item = x; }
33
34			AtomicLinkedNode(Object x, AtomicLinkedNode n) { item = x; next = n; }
35
36			Object getItem() {
37			return item;
38			}
39
40			boolean casItem(Object cmp, Object val) {
41			return itemUpdater.compareAndSet(this, cmp, val);
42			}
43
44			void setItem(Object val) {
45			itemUpdater.set(this, val);
46			}
47
48			AtomicLinkedNode getNext() {
49			return next;
50			}
51
52			boolean casNext(AtomicLinkedNode cmp, AtomicLinkedNode val) {
53			return nextUpdater.compareAndSet(this, cmp, val);
54			}
55
56			void setNext(AtomicLinkedNode val) {
57			nextUpdater.set(this, val);
58			}
59
60			}