Java有鎖并發、無鎖并發和CAS實例分析

這篇文章主要介紹“Java有鎖并發、無鎖并發和CAS實例分析”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Java有鎖并發、無鎖并發和CAS實例分析”文章能幫助大家解決問題。

有鎖并發

   
   
  
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()
    }

}

  
    

   
   
  

無鎖并發

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<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) })

關于“Java有鎖并發、無鎖并發和CAS實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。