Java有锁并发、无锁并发和CAS实例分析

这篇文章主要介绍“Java有锁并发、无锁并发和CAS实例分析”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Java有锁并发、无锁并发和CAS实例分析”文章能帮助大家解决问题。

临海ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！

有锁并发

   
   
  
use std::sync::{Mutex, Arc};

#[derive(Clone)]
struct ConcurrentStack {
   inner: Arc>>,
}

impl ConcurrentStack {
   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 {
       let mut inner = self.inner.lock().unwrap();
       (*inner).pop()
   }

}

  
    

   
   
  

无锁并发

CAS（compare and swap）原语

   
   
  
pub fn compare_and_swap(
   &self,
   current: *mut T,
   new: *mut T,
   order: Ordering
) -> *mut T

  
    

   
   
  

无锁栈（天真版）

   
   
  
#![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 {
   head: AtomicPtr>,
}

struct Node {
   data: T,
   next: *mut Node,
}

impl Stack {
   pub fn new() -> Stack {
       Stack {
           head: AtomicPtr::new(null_mut()),
       }
   }

   pub fn pop(&self) -> Option {
       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) })

关于“Java有锁并发、无锁并发和CAS实例分析”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识，可以关注创新互联行业资讯频道，小编每天都会为大家更新不同的知识点。