mirror of https://github.com/rust-lang/nomicon
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
81 lines
2.2 KiB
81 lines
2.2 KiB
# Final Code
|
|
|
|
Here's the final code, with some added comments and re-ordered imports:
|
|
```rust
|
|
use std::marker::PhantomData;
|
|
use std::ops::Deref;
|
|
use std::ptr::NonNull;
|
|
use std::sync::atomic::{self, AtomicUsize, Ordering};
|
|
|
|
pub struct Arc<T> {
|
|
ptr: NonNull<ArcInner<T>>,
|
|
_marker: PhantomData<ArcInner<T>>,
|
|
}
|
|
|
|
pub struct ArcInner<T> {
|
|
rc: AtomicUsize,
|
|
data: T,
|
|
}
|
|
|
|
impl<T> Arc<T> {
|
|
pub fn new(data: T) -> Arc<T> {
|
|
// We start the reference count at 1, as that first reference is the
|
|
// current pointer.
|
|
let boxed = Box::new(ArcInner {
|
|
rc: AtomicUsize::new(1),
|
|
data,
|
|
});
|
|
Arc {
|
|
// It is okay to call `.unwrap()` here as we get a pointer from
|
|
// `Box::into_raw` which is guaranteed to not be null.
|
|
ptr: NonNull::new(Box::into_raw(boxed)).unwrap(),
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn inner(&self) -> &ArcInner<T> {
|
|
// This unsafety is okay because while this Arc is alive, we're
|
|
// guaranteed that the inner pointer is valid. Also, ArcInner<T> is
|
|
// Sync if T is Sync.
|
|
unsafe { self.ptr.as_ref() }
|
|
}
|
|
}
|
|
|
|
unsafe impl<T: Sync + Send> Send for Arc<T> {}
|
|
unsafe impl<T: Sync + Send> Sync for Arc<T> {}
|
|
|
|
impl<T> Clone for Arc<T> {
|
|
fn clone(&self) -> Arc<T> {
|
|
// Using a relaxed ordering is alright here as knowledge of the original
|
|
// reference prevents other threads from wrongly deleting the object.
|
|
self.inner().rc.fetch_add(1, Ordering::Relaxed);
|
|
Self {
|
|
ptr: self.ptr,
|
|
_marker: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> Drop for Arc<T> {
|
|
fn drop(&mut self) {
|
|
if self.inner().rc.fetch_sub(1, Ordering::Release) != 1 {
|
|
return;
|
|
}
|
|
// This fence is needed to prevent reordering of the use and deletion
|
|
// of the data.
|
|
atomic::fence(Ordering::Acquire);
|
|
// This is safe as we know we have the last pointer to the `ArcInner`
|
|
// and that its pointer is valid.
|
|
unsafe { Box::from_raw(self.ptr.as_ptr()); }
|
|
}
|
|
}
|
|
|
|
impl<T> Deref for Arc<T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &T {
|
|
&self.inner().data
|
|
}
|
|
}
|
|
```
|