单生产者单消费者情景下无锁仓库

最新推荐文章于 2025-02-20 12:02:37 发布

原创最新推荐文章于 2025-02-20 12:02:37 发布 · 653 阅读

0 ·

CC 4.0 BY-SA版权

代码段专栏收录该内容

52 篇文章

订阅专栏

本文介绍了一种使用链表实现的高效并发数据结构，通过原子操作确保了无锁的并发安全性，同时避免了消费延迟，保证了产品的及时消费。

使用链表实现链表中时刻保有两个元素。在任何并发的操作情况下，只要保证赋值是原子操作，即可保证无锁的并发安全。可能导致消费延迟到下一次申请，但是不会出现未消费产品。

package gt.lockFreeList;

public class Node<T> {
	private T data;
	private Node<T> next = null;

	public Node() {

	}

	public Node(T t) {
		// TODO Auto-generated constructor stub
		data = t;
	}

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}

	public Node<T> getNext() {
		return next;
	}

	public void setNext(Node<T> next) {
		this.next = next;
	}

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		@SuppressWarnings("unchecked")
		Node<T> n = ((Node<T>) obj);
		return data.equals(n.data) && (next == n.next);// next pointer should
														// have a same memory
														// pointing
	}

}

package gt.lockFreeList;

public class List<T> {
	private Node<T> head = new Node<T>();
	private Node<T> tail = new Node<T>();
	private boolean used[] = { true, true };

	public List() {
		head.setNext(tail);
	}

	public void put(T t) {
		Node<T> temp = new Node<T>(t);
		tail.setNext(temp);
		tail = temp;
		if (used[0]) {
			pop();
			used[1] = false;
		}
	}

	public T get() {
		T t = null;
		while (canPop() && t == null) {// when there are more than two elements
										// in the list
			if (used[0]) {
				pop();
			} else {
				t = pop();
			}
		}
		if (t == null) {// when there are exactly two elements in the list keep
						// them as placeholder
			if (used[0]) {
				if (used[1]) {
				} else {
					used[1] = true;
					t = head.getNext().getData();
				}
			} else {
				used[0] = true;
				t = head.getData();
			}
		}
		return t;
	}

	public T pop() {
		Node<T> h = head;
		head = h.getNext();
		used[0] = used[1];
		return h.getData();
	}

	public boolean canPop() {
		return !(head.getNext() == tail);
	}
}

可能有分析错误求指正