最终代码

这是最终代码，添加了一些注释和重新排序的导入：

  1. use std::marker::PhantomData;
  2. use std::ops::Deref;
  3. use std::ptr::NonNull;
  4. use std::sync::atomic::{self, AtomicUsize, Ordering};
  6. pub struct Arc<T> {
  7.     ptr: NonNull<ArcInner<T>>,
  8.     phantom: PhantomData<ArcInner<T>>,
  9. }
  11. pub struct ArcInner<T> {
  12.     rc: AtomicUsize,
  13.     data: T,
  14. }
  16. impl<T> Arc<T> {
  17.     pub fn new(data: T) -> Arc<T> {
  18.         // We start the reference count at 1, as that first reference is the
  19.         // current pointer.
  20.         let boxed = Box::new(ArcInner {
  21.             rc: AtomicUsize::new(1),
  22.             data,
  23.         });
  24.         Arc {
  25.             // It is okay to call `.unwrap()` here as we get a pointer from
  26.             // `Box::into_raw` which is guaranteed to not be null.
  27.             ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
  28.             phantom: PhantomData,
  29.         }
  30.     }
  31. }
  33. unsafe impl<T: Sync + Send> Send for Arc<T> {}
  34. unsafe impl<T: Sync + Send> Sync for Arc<T> {}
  36. impl<T> Deref for Arc<T> {
  37.     type Target = T;
  38.     fn deref(&self) -> &T {
  39.         let inner = unsafe { self.ptr.as_ref() };
  40.         &inner.data
  41.     }
  42. }
  44. impl<T> Clone for Arc<T> {
  45.     fn clone(&self) -> Arc<T> {
  46.         let inner = unsafe { self.ptr.as_ref() };
  47.         // Using a relaxed ordering is alright here as we don't need any atomic
  48.         // synchronization here as we're not modifying or accessing the inner
  49.         // data.
  50.         let old_rc = inner.rc.fetch_add(1, Ordering::Relaxed);
  51.         if old_rc >= isize::MAX as usize {
  52.             std::process::abort();
  53.         }
  55.         Self {
  56.             ptr: self.ptr,
  57.             phantom: PhantomData,
  58.         }
  59.     }
  60. }
  62. impl<T> Drop for Arc<T> {
  63.     fn drop(&mut self) {
  64.         let inner = unsafe { self.ptr.as_ref() };
  65.         if inner.rc.fetch_sub(1, Ordering::Release) != 1 {
  66.             return;
  67.         }
  68.         // This fence is needed to prevent reordering of the use and deletion
  69.         // of the data.
  70.         atomic::fence(Ordering::Acquire);
  71.         // This is safe as we know we have the last pointer to the `ArcInner`
  72.         // and that its pointer is valid.
  73.         unsafe { Box::from_raw(self.ptr.as_ptr()); }
  74.     }
  75. }