Tokio

https://docs.rs/tokio/latest/tokio/
Admin
Tokio is an event-driven, non-blocking I/O platform and runtime for writing reliable asynchronous...
Tokens:1,485,759
Snippets:10,447
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Corrected sleep setup (partial)

Source: https://docs.rs/tokio/latest/tokio/macro.select.html

Partial example showing the setup for the corrected version of the racy if precondition example. The source text is truncated; the full corrected loop is not shown.

```rust
use tokio::time::{self, Duration};

async fn some_async_work() {
    // do work
}

let sleep = time::sleep(Duration::from_millis(50));
tokio::pin!(sleep);
```

--------------------------------

### Avoid racy if preconditions (corrected example, partial)

Source: https://docs.rs/tokio/latest/tokio/macro.select.html?search=u32+-%3E+bool

Partial example showing the start of a corrected version without the race. The source text is cut off, so only the initial setup is visible.

```rust
use tokio::time::{self, Duration};

async fn some_async_work() {
    // do work
}

let sleep = time::sleep(Duration::from_millis(50));
tokio::pin!(sleep);


```

--------------------------------

### take example with File

Source: https://docs.rs/tokio/latest/tokio/io/trait.AsyncReadExt.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example usage of take on a File. Creates an adaptor that reads at most five bytes into a fixed-size buffer. After the limit is reached, reads return EOF.

```rust
use tokio::io::{self, AsyncReadExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let f = File::open("foo.txt").await?;
    let mut buffer = [0; 5];

    // read at most five bytes
    let mut handle = f.take(5);

    handle.read(&mut buffer).await?;
    Ok(())
}
```

--------------------------------

### build example: create a Runtime

Source: https://docs.rs/tokio/latest/tokio/runtime/struct.Builder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Builds a Runtime instance ready to spawn tasks. The example creates a multi-thread runtime and runs a simple async block that prints a message.

```rust
use tokio::runtime::Builder;

let rt  = Builder::new_multi_thread().build().unwrap();

rt.block_on(async {
    println!("Hello from the Tokio runtime");
});

```

--------------------------------

### ttl example

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpStream.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the IP_TTL option value for the socket and prints it. The example connects to 127.0.0.1:8080 and prints the TTL.

```rust
use tokio::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

println!("{:?}", stream.ttl()?);
```

--------------------------------

### Example: Using watch::channel to print values

Source: https://docs.rs/tokio/latest/tokio/sync/watch/fn.channel.html

Shows how to create a watch channel, spawn a task that loops until the sender is dropped, and send a value after a delay. The example prints `hello! world! `.

```rust
use tokio::sync::watch;
use tokio::time::{Duration, sleep};

let (tx, mut rx) = watch::channel("hello");

tokio::spawn(async move {
    // Use the equivalent of a "do-while" loop so the initial value is
    // processed before awaiting the `changed()` future.
    loop {
        println!("{}! ", *rx.borrow_and_update());
        if rx.changed().await.is_err() {
            break;
        }
    }
});

sleep(Duration::from_millis(100)).await;
tx.send("world")?;
```

--------------------------------

### local_addr example

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpSocket.html

Gets the local address of the socket. The example binds the socket to 127.0.0.1:8080, asserts the local address, and then creates a listener.

```rust
use tokio::net::TcpSocket;

use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
    let addr = "127.0.0.1:8080".parse().unwrap();

    let socket = TcpSocket::new_v4()?;
    socket.bind(addr)?;
    assert_eq!(socket.local_addr().unwrap().to_string(), "127.0.0.1:8080");
    let listener = socket.listen(1024)?;
    Ok(())
}
```

--------------------------------

### connect example

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpSocket.html

Establishes a TCP connection with a peer. The example creates a new IPv4 socket and connects to 127.0.0.1:8080, returning a TcpStream.

```rust
use tokio::net::TcpSocket;

use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
    let addr = "127.0.0.1:8080".parse().unwrap();

    let socket = TcpSocket::new_v4()?;
    let stream = socket.connect(addr).await?;

    Ok(())
}
```

--------------------------------

### create: Create named pipe server

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ServerOptions.html?search=

Example for ServerOptions::create, showing how to create a named pipe server. The full example is truncated in the source; only the import and constant are shown.

```rust
use tokio::net::windows::named_pipe::ServerOptions;

const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-create";
```

--------------------------------

### nodelay example

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpSocket.html

Gets the current value of the TCP_NODELAY option. The example creates a new IPv4 socket and prints the result of nodelay().

```rust
use tokio::net::TcpSocket;

let socket = TcpSocket::new_v4()?;

println!("{:?}", socket.nodelay()?);
```

--------------------------------

### rwlock example: get reference to original Arc<RwLock>

Source: https://docs.rs/tokio/latest/tokio/sync/struct.OwnedRwLockWriteGuard.html

Shows how to use OwnedRwLockWriteGuard::rwlock to get a reference to the original Arc<RwLock>. The example creates an Arc<RwLock>, acquires a write guard, and asserts that the reference returned by rwlock is the same as the original Arc.

```rust
use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockWriteGuard};

let lock = Arc::new(RwLock::new(1));

let guard = lock.clone().write_owned().await;
assert!(Arc::ptr_eq(&lock, OwnedRwLockWriteGuard::rwlock(&guard)));
```

--------------------------------

### create

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ServerOptions.html?search=u32+-%3E+bool

Documentation for the create method on ServerOptions.

```APIDOC
## create

### Description
Creates the named pipe identified by `addr` for use as a server. This uses the `CreateNamedPipe` function.

### Method
`create(&self, addr: impl AsRef<OsStr>) -> Result<NamedPipeServer>`

### Parameters
- **addr** (impl AsRef<OsStr>) - Required - The address of the named pipe.

### Returns
- `Result<NamedPipeServer>` - The created named pipe server.

### Errors
This errors if called outside of a Tokio Runtime, or in a runtime that has not enabled I/O, or if any OS-specific I/O errors occur.

### Examples
```rust
use tokio::net::windows::named_pipe::ServerOptions;

const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-create";
```
```

--------------------------------

### ttl: Get IP_TTL value

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpListener.html

Gets the value of the IP_TTL option for the socket. The example sets TTL to 100 and asserts the retrieved value.

```rust
use tokio::net::TcpListener;

use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
   let listener = TcpListener::bind("127.0.0.1:0").await?;

   listener.set_ttl(100).expect("could not set TTL");
   assert_eq!(listener.ttl()?, 100);

   Ok(())
}
```

--------------------------------

### write_dac examples: success and access denied

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ServerOptions.html

Two examples for ServerOptions::write_dac. The first sets write_dac(true) and expects ERROR_SUCCESS from SetSecurityInfo; the second sets write_dac(false) and expects ERROR_ACCESS_DENIED. Both use a distinct pipe name and require the windows_sys crate.

```rust
use std::{io, os::windows::prelude::AsRawHandle, ptr};

use tokio::net::windows::named_pipe::ServerOptions;
use windows_sys::{
    Win32::Foundation::ERROR_SUCCESS,
    Win32::Security::DACL_SECURITY_INFORMATION,
    Win32::Security::Authorization::{SetSecurityInfo, SE_KERNEL_OBJECT},
};

const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe";

let mut pipe_template = ServerOptions::new();
pipe_template.write_dac(true);
let pipe = pipe_template.create(PIPE_NAME)?;

unsafe {
    assert_eq!(
        ERROR_SUCCESS,
        SetSecurityInfo(
            pipe.as_raw_handle() as _,
            SE_KERNEL_OBJECT,
            DACL_SECURITY_INFORMATION,
            ptr::null_mut(),
            ptr::null_mut(),
            ptr::null_mut(),
            ptr::null_mut(),
        )
    );
}

```

```rust
use std::{io, os::windows::prelude::AsRawHandle, ptr};

use tokio::net::windows::named_pipe::ServerOptions;
use windows_sys::{
    Win32::Foundation::ERROR_ACCESS_DENIED,
    Win32::Security::DACL_SECURITY_INFORMATION,
    Win32::Security::Authorization::{SetSecurityInfo, SE_KERNEL_OBJECT},
};

const PIPE_NAME: &str = r"\\.\pipe\write_dac_pipe_fail";

let mut pipe_template = ServerOptions::new();
pipe_template.write_dac(false);
let pipe = pipe_template.create(PIPE_NAME)?;

unsafe {
    assert_eq!(
        ERROR_ACCESS_DENIED,
        SetSecurityInfo(
            pipe.as_raw_handle() as _,
            SE_KERNEL_OBJECT,
            DACL_SECURITY_INFORMATION,
            ptr::null_mut(),
            ptr::null_mut(),
            ptr::null_mut(),
            ptr::null_mut(),
        )
    );
}

```

--------------------------------

### Example: get worker index in spawned task

Source: https://docs.rs/tokio/latest/tokio/runtime/fn.worker_index.html?search=

Example usage of worker_index inside a spawned task on a multi-thread runtime. The task prints the worker index it ran on.

```rust
#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() {
    let index = tokio::spawn(async {
        tokio::runtime::worker_index()
    }).await.unwrap();
    println!("Task ran on worker {:?}", index);
}
```

--------------------------------

### Example: reading from a File using read

Source: https://docs.rs/tokio/latest/tokio/io/trait.AsyncReadExt.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to use `read` with a `File` and a byte array buffer. It opens a file, reads up to 10 bytes, and prints the bytes.

```rust
use tokio::fs::File;
use tokio::io::{self, AsyncReadExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt").await?;
    let mut buffer = [0; 10];

    // read up to 10 bytes
    let n = f.read(&mut buffer[..]).await?;

    println!("The bytes: {:?}", &buffer[..n]);
    Ok(())
}
```

--------------------------------

### rwlock example: OwnedRwLockMappedWriteGuard::rwlock

Source: https://docs.rs/tokio/latest/tokio/sync/struct.OwnedRwLockMappedWriteGuard.html?search=u32+-%3E+bool

Shows how to get a reference to the original Arc<RwLock> from a mapped guard. The example creates a guard, maps it, and checks that the Arc pointer is equal.

```rust
use std::sync::Arc;
use tokio::sync::{
    RwLock,
    OwnedRwLockWriteGuard,
    OwnedRwLockMappedWriteGuard,
};

let lock = Arc::new(RwLock::new(1));

let guard = lock.clone().write_owned().await;
let guard = OwnedRwLockWriteGuard::map(guard, |x| x);
assert!(Arc::ptr_eq(&lock, OwnedRwLockMappedWriteGuard::rwlock(&guard)));
```

--------------------------------

### flush example

Source: https://docs.rs/tokio/latest/tokio/io/trait.AsyncWriteExt.html

Example for flush. Creates a file, wraps it in BufWriter, writes bytes, and flushes. Demonstrates using flush to ensure buffered data is written.

```rust
use tokio::io::{self, BufWriter, AsyncWriteExt};
use tokio::fs::File;

#[tokio::main]
async fn main() -> io::Result<()> {
    let f = File::create("foo.txt").await?;
    let mut buffer = BufWriter::new(f);

    buffer.write_all(b"some bytes").await?;
    buffer.flush().await?;
    Ok(())
}
```

--------------------------------

### Example: Writing to stdout with write_all

Source: https://docs.rs/tokio/latest/tokio/io/fn.stdout.html?search=

A complete Tokio program that creates a `stdout` handle and writes "Hello world!" to it. Uses `AsyncWriteExt` for the `write_all` method.

```rust
use tokio::io::{self, AsyncWriteExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut stdout = io::stdout();
    stdout.write_all(b"Hello world!").await?;
    Ok(())
}
```

--------------------------------

### Delay behavior example

Source: https://docs.rs/tokio/latest/tokio/time/enum.MissedTickBehavior.html

Shows the Delay strategy where future ticks are scheduled from the moment tick is called, not from the original start. Ticks are not shortened and may not align with multiples of the period from start.

```rust
use tokio::time::{interval, Duration, MissedTickBehavior};

let mut interval = interval(Duration::from_millis(50));
interval.set_missed_tick_behavior(MissedTickBehavior::Delay);

task_that_takes_more_than_50_millis().await;
// The `Interval` has missed a tick

// Since we have exceeded our timeout, this will resolve immediately
interval.tick().await;

// But this one, rather than also resolving immediately, as might happen
// with the `Burst` or `Skip` behaviors, will not resolve until
// 50ms after the call to `tick` up above. That is, in `tick`, when we
// recognize that we missed a tick, we schedule the next tick to happen
// 50ms (or whatever the `period` is) from right then, not from when
// were *supposed* to tick
interval.tick().await;
```

--------------------------------

### remove example

Source: https://docs.rs/tokio/latest/tokio/io/struct.Interest.html

Removes an Interest from another, ignoring interests not present. Returns None if the set would become empty; the example shows removing READABLE, then removing the remaining WRITABLE to get None, and removing all at once.

```rust
use tokio::io::Interest;

const RW_INTEREST: Interest = Interest::READABLE.add(Interest::WRITABLE);

let w_interest = RW_INTEREST.remove(Interest::READABLE).unwrap();
assert!(!w_interest.is_readable());
assert!(w_interest.is_writable());

// Removing all interests from the set returns `None`.
assert_eq!(w_interest.remove(Interest::WRITABLE), None);

// Remove all interests at once.
assert_eq!(RW_INTEREST.remove(RW_INTEREST), None);
```

--------------------------------

### Example: Listening for CTRL-SHUTDOWN events

Source: https://docs.rs/tokio/latest/tokio/signal/windows/fn.ctrl_shutdown.html

An example that creates a listener for CTRL-SHUTDOWN notifications, awaits a signal, and prints a cleanup message. Uses `#[tokio::main]` and requires the `signal` feature on Windows.

```rust
use tokio::signal::windows::ctrl_shutdown;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A listener of CTRL-SHUTDOWN events.
    let mut signal = ctrl_shutdown()?;

    signal.recv().await;
    println!("got CTRL-SHUTDOWN. Cleaning up before exiting");

    Ok(())
}
```

--------------------------------

### subscribe() example - new receiver gets latest value

Source: https://docs.rs/tokio/latest/tokio/sync/watch/struct.Sender.html

Creates a new Receiver connected to this Sender. Messages sent before subscribe are marked as seen. The example shows that a new receiver sees the most recent value sent before subscribing.

```rust
use tokio::sync::watch;

let (tx, _rx) = watch::channel(0u64);

tx.send(5).unwrap();

let rx = tx.subscribe();
assert_eq!(5, *rx.borrow());

tx.send(10).unwrap();
assert_eq!(10, *rx.borrow());
```

--------------------------------

### ready example

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpStream.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Concurrently reads and writes to a TcpStream on the same task using ready() with Interest::READABLE | Interest::WRITABLE, handling WouldBlock errors.

```rust
use tokio::io::Interest;
use tokio::net::TcpStream;
use std::error::Error;
use std::io;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let stream = TcpStream::connect("127.0.0.1:8080").await?;

    loop {
        let ready = stream.ready(Interest::READABLE | Interest::WRITABLE).await?;

        if ready.is_readable() {
            let mut data = vec![0; 1024];
            // Try to read data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_read(&mut data) {
                Ok(n) => {
                    println!("read {} bytes", n);
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e.into());
                }
            }

        }

        if ready.is_writable() {
            // Try to write data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_write(b"hello world") {
                Ok(n) => {
                    println!("write {} bytes", n);
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue
                }
                Err(e) => {
                    return Err(e.into());
                }
            }
        }
    }
}
```

--------------------------------

### Example: using mpsc::channel with tokio::spawn

Source: https://docs.rs/tokio/latest/tokio/sync/mpsc/fn.channel.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to create a channel with a buffer of 100, spawn a task that sends 10 messages, and receive them in the main task. Shows handling of send errors when the receiver is dropped.

```rust
use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::channel(100);

tokio::spawn(async move {
    for i in 0..10 {
        if let Err(_) = tx.send(i).await {
            println!("receiver dropped");
            return;
        }
    }
});

while let Some(i) = rx.recv().await {
     println!("got = {}", i);
}
```

--------------------------------

### Get full path with DirEntry::path() and example output

Source: https://docs.rs/tokio/latest/tokio/fs/struct.DirEntry.html?search=u32+-%3E+bool

Example for the path() method, which returns the full path to the file that this entry represents. The full path is created by joining the original path to read_dir with the filename of this entry. The example prints the full path for each entry, and the output shows the format of the printed paths.

```rust
use tokio::fs;

let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    println!("{:?}", entry.path());
}
```

```text
"./whatever.txt"
"./foo.html"
"./hello_world.rs"
```

--------------------------------

### Create a named pipe client with ClientOptions::new()

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ClientOptions.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to create a named pipe client with default settings. The server must be created first for the client creation to succeed.

```rust
use tokio::net::windows::named_pipe::{ServerOptions, ClientOptions};

const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-client-new";

// Server must be created in order for the client creation to succeed.
let server = ServerOptions::new().create(PIPE_NAME)?;
let client = ClientOptions::new().open(PIPE_NAME)?;
```

--------------------------------

### Get local address of a TcpStream

Source: https://docs.rs/tokio/latest/tokio/net/struct.TcpStream.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the local address that the stream is bound to using `local_addr`. Example prints the address.

```rust
use tokio::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

println!("{:?}", stream.local_addr()?);
```

--------------------------------

### SetOnce static usage with const_new

Source: https://docs.rs/tokio/latest/tokio/sync/struct.SetOnce.html?search=

Shows how to create a static SetOnce using const_new, set its value from a spawned task, check with get, and wait asynchronously with wait(). The example uses tokio::spawn and prints the result of get() and wait().

```rust
use tokio::sync::{SetOnce, SetOnceError};

static ONCE: SetOnce<u32> = SetOnce::const_new();


// set the value inside a task somewhere...
tokio::spawn(async move { ONCE.set(20) });

// checking with .get doesn't block main thread
println!("{:?}", ONCE.get());

// wait until the value is set, blocks the thread
println!("{:?}", ONCE.wait().await);

Ok(())
```

--------------------------------

### Opening a file for reading and writing, creating if it doesn't exist

Source: https://docs.rs/tokio/latest/tokio/fs/struct.OpenOptions.html?search=

Opens a file for both reading and writing, creating it if it doesn't exist, using `OpenOptions::new().read(true).write(true).create(true).open("foo.txt")`. The `open` method is awaited and returns an `io::Result<File>`. This example is from the Tokio documentation for `OpenOptions`.

```rust
use tokio::fs::OpenOptions;
use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
    let file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open("foo.txt")
        .await?;

    Ok(())
}
```

--------------------------------

### Get bare file name with DirEntry::file_name()

Source: https://docs.rs/tokio/latest/tokio/fs/struct.DirEntry.html?search=u32+-%3E+bool

Example for the file_name() method, which returns the bare file name of this directory entry without any other leading path component. The example reads the current directory and prints the file name for each entry.

```rust
use tokio::fs;

let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    println!("{:?}", entry.file_name());
}
```

--------------------------------

### Get inode number with DirEntry::ino()

Source: https://docs.rs/tokio/latest/tokio/fs/struct.DirEntry.html?search=u32+-%3E+bool

Example for the ino() method, available on Unix only. It returns the underlying d_ino field in the contained dirent structure. The example reads the current directory and prints the file name and inode number for each entry.

```rust
use tokio::fs;

let mut entries = fs::read_dir(".").await?;
while let Some(entry) = entries.next_entry().await? {
    // Here, `entry` is a `DirEntry`.
    println!("{:?}: {}", entry.file_name(), entry.ino());
}
```

--------------------------------

### SetOnce::new

Source: https://docs.rs/tokio/latest/tokio/sync/struct.SetOnce.html

Creates a new SetOnce instance at runtime.

```APIDOC
## SetOnce::new

### Description
Creates a new `SetOnce` instance at runtime.

### Method
fn new() -> SetOnce<T>

### Parameters
None.

### Returns
- **SetOnce<T>** - A new empty `SetOnce` instance.

### Example
```rust
use tokio::sync::SetOnce;

let once = SetOnce::new();
```
```

--------------------------------

### create example: tokio-named-pipe-create

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ServerOptions.html

Example for ServerOptions::create. Shows creating a named pipe server with a constant pipe name. The example is truncated in the source.

```rust
use tokio::net::windows::named_pipe::ServerOptions;

const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-create";

```

--------------------------------

### SignalKind::as_raw_value usage

Source: https://docs.rs/tokio/latest/tokio/signal/unix/struct.SignalKind.html?search=

Gets the numeric value of a signal. The example asserts that the interrupt signal's value equals libc::SIGINT.

```rust
let kind = SignalKind::interrupt();
assert_eq!(kind.as_raw_value(), libc::SIGINT);
```

--------------------------------

### Example for borrow method

Source: https://docs.rs/tokio/latest/tokio/sync/watch/struct.Receiver.html

Shows how to use borrow() to get a reference to the most recently sent value. The receiver is created with watch::channel and the value is asserted.

```rust
use tokio::sync::watch;

let (_, rx) = watch::channel("hello");
assert_eq!(*rx.borrow(), "hello");
```

--------------------------------

### max_instances example: ERROR_PIPE_BUSY

Source: https://docs.rs/tokio/latest/tokio/net/windows/named_pipe/struct.ServerOptions.html

Example for ServerOptions::max_instances. Creates two server instances with max_instances(2), then shows that a third create fails with ERROR_PIPE_BUSY, even when max_instances is raised to 100. Requires the windows_sys crate.

```rust
use std::io;
use tokio::net::windows::named_pipe::{ServerOptions, ClientOptions};
use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;

const PIPE_NAME: &str = r"\\.\pipe\tokio-named-pipe-max-instances";

let mut server = ServerOptions::new();
server.max_instances(2);

let s1 = server.create(PIPE_NAME)?;
let c1 = ClientOptions::new().open(PIPE_NAME);

let s2 = server.create(PIPE_NAME)?;
let c2 = ClientOptions::new().open(PIPE_NAME);

// Too many servers!
let e = server.create(PIPE_NAME).unwrap_err();
assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_BUSY as i32));

// Still too many servers even if we specify a higher value!
let e = server.max_instances(100).create(PIPE_NAME).unwrap_err();
assert_eq!(e.raw_os_error(), Some(ERROR_PIPE_BUSY as i32));

```

--------------------------------

### Build a multi-threaded runtime with custom settings

Source: https://docs.rs/tokio/latest/tokio/runtime/struct.Builder.html?search=u32+-%3E+bool

Example from the 'Examples' section showing how to create a multi-threaded runtime with custom worker threads, thread name, and stack size. The `build()` method returns a `Result` that is unwrapped.

```rust
use tokio::runtime::Builder;

fn main() {
    // build runtime
    let runtime = Builder::new_multi_thread()
        .worker_threads(4)
        .thread_name("my-custom-name")
        .thread_stack_size(3 * 1024 * 1024)
        .build()
        .unwrap();

    // use runtime ...
}
```

--------------------------------

### resubscribe example

Source: https://docs.rs/tokio/latest/tokio/sync/broadcast/struct.Receiver.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to resubscribe to a broadcast channel from the current tail element. The new receiver only gets values sent after resubscription, not those already queued.

```rust
use tokio::sync::broadcast;

let (tx, mut rx) = broadcast::channel(2);

tx.send(1).unwrap();
let mut rx2 = rx.resubscribe();
tx.send(2).unwrap();

assert_eq!(rx2.recv().await.unwrap(), 2);
assert_eq!(rx.recv().await.unwrap(), 1);
```
Tokens:
Raw