Sync and Send
There are two key traits that the parallel Rust programmer must understand—Send
and Sync
. The Send
trait is applied to types that can be transferred across thread boundaries. That is, any type T: Send
is safe to move from one thread to another. Rc<T>: !Send
means that it is explicitly marked as being unsafe to move between threads. Why? Consider if it were marked Send
; what would happen? We know from the previous chapter that Rc<T>
is a boxed T
with two counters in place for weak and strong references to T
. These counters are the trick. Suppose we spread an Rc<T>
across two threads—call them A
and B
—each of which created references, dropped them, and the like. What would happen if both A
and B
dropped the last reference to Rc<T>
at the same time? We have a race between either thread to see which can deallocate T
first and which will suffer a double-free for its troubles. Worse, suppose the taking of the strong reference counter in Rc<T>
were spread...