#atomic #take #lock-free #option

no-std atomic-take

Atomically take a value out of a container once

3 releases (stable)

1.1.0 Jan 28, 2023
1.0.0 Dec 14, 2019
0.1.0 Oct 23, 2019

#30 in Concurrency

Download history 32776/week @ 2023-08-08 37281/week @ 2023-08-15 46085/week @ 2023-08-22 61942/week @ 2023-08-29 59435/week @ 2023-09-05 59958/week @ 2023-09-12 53998/week @ 2023-09-19 56053/week @ 2023-09-26 58756/week @ 2023-10-03 61383/week @ 2023-10-10 62347/week @ 2023-10-17 64671/week @ 2023-10-24 74506/week @ 2023-10-31 67772/week @ 2023-11-07 70088/week @ 2023-11-14 60130/week @ 2023-11-21

283,921 downloads per month
Used in 245 crates (10 directly)

MIT license

181 lines

Atomic Take

License Cargo Documentation

This crate allows you to store a value that you can later take out atomically. As this crate uses atomics, no locking is involved in taking the value out.

As an example, you could store the Sender of an oneshot channel in an AtomicTake, which would allow you to notify the first time a closure is called.

use atomic_take::AtomicTake;
use tokio::sync::oneshot;

let (send, mut recv) = oneshot::channel();

let take = AtomicTake::new(send);
let closure = move || {
    if let Some(send) = take.take() {
        // Notify the first time this closure is called.

assert_eq!(recv.try_recv().unwrap(), Some(()));

closure(); // This does nothing.

Additionally the closure above can be called concurrently from many threads. For example, if you put the AtomicTake in an Arc, you can share it between several threads and receive a message from the first thread to run.

use std::thread;
use std::sync::Arc;
use atomic_take::AtomicTake;
use tokio::sync::oneshot;

let (send, mut recv) = oneshot::channel();

// Use an Arc to share the AtomicTake between several threads.
let take = Arc::new(AtomicTake::new(send));

// Spawn three threads and try to send a message from each.
let mut handles = Vec::new();
for i in 0..3 {
    let take_clone = Arc::clone(&take);
    let join_handle = thread::spawn(move || {

        // Check if this thread is first and send a message if so.
        if let Some(send) = take_clone.take() {
            // Send the index of the thread.

// Wait for all three threads to finish.
for handle in handles {

// After all the threads finished, try to send again.
if let Some(send) = take.take() {
    // This will definitely not happen.

// Confirm that one of the first three threads got to send the message first.
assert!(recv.try_recv().unwrap().unwrap() < 3);

This crate does not require the standard library.

Supported Rust Versions

The current MSRV is 1.48.0. It may also work on earlier compiler versions, but they are not tested in CI when changes are made.


This project is licensed under the MIT license.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, shall be licensed as MIT, without any additional terms or conditions.

No runtime deps