play.rust-lang.org example for Mutex pulls up source for Mutex and Poisoning together #22523

   fn main() {
        use std::sync::{Arc, Mutex};
        use std::thread::Thread;
        use std::sync::mpsc::channel;

        const N: uint = 10;

        // Spawn a few threads to increment a shared variable (non-atomically), and
        // let the main thread know once all increments are done.
        //
        // Here we're using an Arc to share memory among tasks, and the data inside
        // the Arc is protected with a mutex.
        let data = Arc::new(Mutex::new(0));

        let (tx, rx) = channel();
        for _ in 0u..10 {
            let (data, tx) = (data.clone(), tx.clone());
            Thread::spawn(move || {
                // The shared static can only be accessed once the lock is held.
                // Our non-atomic increment is safe because we're the only thread
                // which can access the shared state when the lock is held.
                //
                // We unwrap() the return value to assert that we are not expecting
                // tasks to ever fail while holding the lock.
                let mut data = data.lock().unwrap();
                *data += 1;
                if *data == N {
                    tx.send(()).unwrap();
                }
                // the lock is unlocked here when `data` goes out of scope.
            });
        }

        rx.recv().unwrap();
    }fn main() {
        use std::sync::{Arc, Mutex};
        use std::thread::Thread;

        let lock = Arc::new(Mutex::new(0u));
        let lock2 = lock.clone();

        let _ = Thread::scoped(move || -> () {
            // This thread will acquire the mutex first, unwrapping the result of
            // `lock` because the lock has not been poisoned.
            let _lock = lock2.lock().unwrap();

            // This panic while holding the lock (`_guard` is in scope) will poison
            // the mutex.
            panic!();
        }).join();

        // The lock is poisoned by this point, but the returned result can be
        // pattern matched on to return the underlying guard on both branches.
        let mut guard = match lock.lock() {
            Ok(guard) => guard,
            Err(poisoned) => poisoned.into_guard(),
        };

        *guard += 1;
    }