这篇文章主要介绍“Java有锁并发、无锁并发和CAS实例分析”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Java有锁并发、无锁并发和CAS实例分析”文章能帮助大家解决问题。
std::sync::Mutex
。（加上Arc是为了能让多个线程都拥有栈的所有权）
use std::sync::{Mutex, Arc};
#[derive(Clone)]
struct ConcurrentStack<T> {
inner: Arc<Mutex<Vec<T>>>,
}
impl<T> ConcurrentStack<T> {
pub fn new() -> Self {
ConcurrentStack {
inner: Arc::new(Mutex::new(Vec::new())),
}
}
pub fn push(&self, data: T) {
let mut inner = self.inner.lock().unwrap();
(*inner).push(data);
}
pub fn pop(&self) -> Option<T> {
let mut inner = self.inner.lock().unwrap();
(*inner).pop()
}
}
std::sync::atomic
中的类型就提供了CAS操作，比如原子指针
std::sync::atomic::AtomicPtr
pub fn compare_and_swap(
&self,
current: *mut T,
new: *mut T,
order: Ordering
) -> *mut T
Acquire
,
Release
,
Relaxed
）
#![feature(box_raw)]
use std::ptr::{self, null_mut};
use std::sync::atomic::AtomicPtr;
use std::sync::atomic::Ordering::{Relaxed, Release, Acquire};
pub struct Stack<T> {
head: AtomicPtr<Node<T>>,
}
struct Node<T> {
data: T,
next: *mut Node<T>,
}
impl<T> Stack<T> {
pub fn new() -> Stack<T> {
Stack {
head: AtomicPtr::new(null_mut()),
}
}
pub fn pop(&self) -> Option<T> {
loop {
// 快照
let head = self.head.load(Acquire);
// 如果栈为空
if head == null_mut() {
return None
} else {
let next = unsafe { (*head).next };
// 如果现状较快照并没有发生改变
if self.head.compare_and_swap(head, next, Release) == head {
// 读取内容并返回
return Some(unsafe { ptr::read(&(*head).data) })
}
}
}
}
pub fn push(&self, t: T) {
// 创建node并转化为*mut指针
let n = Box::into_raw(Box::new(Node {
data: t,
next: null_mut(),
}));
loop {
// 快照
let head = self.head.load(Relaxed);
// 基于快照更新node
unsafe { (*n).next = head; }
// 如果在此期间，快照仍然没有过时
if self.head.compare_and_swap(head, n, Release) == head {
break
}
}
}
}
return Some(unsafe { ptr::read(&(*head).data) })head
，这是一个内存泄漏！哎，看来无锁并发好不容易呢。关于“Java有锁并发、无锁并发和CAS实例分析”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识，可以关注亿速云行业资讯频道，小编每天都会为大家更新不同的知识点。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
