Tokio

https://docs.rs/tokio/1.49.0/
Admin
Tokio is an event-driven, non-blocking I/O runtime for writing reliable asynchronous network...
Tokens:1,290,964
Snippets:8,980
Trust Score:9.7
Update:7 hours ago
Show doc for...
Tokens:
Raw
### quickack example

Source: https://docs.rs/tokio/1.49.0/tokio/net/struct.TcpStream.html

Connects to a peer and gets the value of the TCP_QUICKACK option. Available on Linux or Android or Fuchsia or Cygwin only.

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

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

stream.quickack()?;
```

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

### capacity example

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/mpsc/bounded.rs.html

Shows how to get the current capacity of the channel. The example creates a channel with capacity 5, reserves a permit to reduce capacity, and then sends and receives to restore it.

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

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let (tx, mut rx) = mpsc::channel::<()>(5);

assert_eq!(tx.capacity(), 5);

// Making a reservation drops the capacity by one.
let permit = tx.reserve().await.unwrap();
assert_eq!(tx.capacity(), 4);

// Sending and receiving a value increases the capacity by one.
permit.send(());
rx.recv().await.unwrap();
assert_eq!(tx.capacity(), 5);
# }
```

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

### Get TCP_QUICKACK option with quickack()

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/tcp/stream.rs.html

Example for TcpStream::quickack() that connects to a local server and retrieves the TCP_QUICKACK option value. This method is only available on Linux, Android, Fuchsia, and Cygwin. The example is marked no_run and uses an async function.

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

# async fn dox() -> Result<(), Box<dyn std::error::Error>> {
let stream = TcpStream::connect("127.0.0.1:8080").await?;

stream.quickack()?;
# Ok(())
# }
```

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

### Create IPv4 socket and start listening

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/tcp/socket.rs.html

Example for TcpSocket::new_v4() that creates a socket, binds to 127.0.0.1:8080, and listens with a backlog of 128.

```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)?;

    let listener = socket.listen(128)?;
# drop(listener);
    Ok(())
}
```

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

### interval_at example with delayed start

Source: https://docs.rs/tokio/1.49.0/src/tokio/time/interval.rs.html

Example showing how to use interval_at to create an interval that starts after a specified delay and then ticks every 10ms.

```rust
use tokio::time::{interval_at, Duration, Instant};

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let start = Instant::now() + Duration::from_millis(50);
let mut interval = interval_at(start, Duration::from_millis(10));

interval.tick().await; // ticks after 50ms
interval.tick().await; // ticks after 10ms
interval.tick().await; // ticks after 10ms

// approximately 70ms have elapsed.
# }
```

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

### create example

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

Creates a named pipe server with default options.

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

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

let server = ServerOptions::new().create(PIPE_NAME)?;
```

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

### Get worker park count with tokio::runtime::Handle

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/metrics/runtime.rs.html

Example for worker_park_count. It uses Handle::current().metrics() to get the metrics and then calls worker_park_count(0) to get the number of times worker 0 has parked. The example is wrapped in a current_thread Tokio runtime.

```rust
use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.worker_park_count(0);
println!("worker 0 parked {} times", n);
# }

```

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

### build method example

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/builder.rs.html

Creates the configured Runtime instance, ready to spawn tasks. The example builds a multi-thread runtime and runs a simple async block.

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

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

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

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

### Get LocalSet ID with tokio::task::LocalSet::id

Source: https://docs.rs/tokio/1.49.0/src/tokio/task/local.rs.html

Example showing how to get the ID of a LocalSet using the id() method. The example is wrapped in a #[tokio::main] attribute with the current_thread flavor.

```rust
use tokio::task;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let local_set = task::LocalSet::new();
println!("Local set id: {}", local_set.id());
# }
```

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

### Get a mutable reference to the underlying data

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/mutex.rs.html

Example for Mutex::get_mut, which returns a mutable reference to the inner value without locking. The example creates a Mutex, gets a mutable reference, and modifies the value to 2.

```rust
use tokio::sync::Mutex;

fn main() {
    let mut mutex = Mutex::new(1);

    let n = mutex.get_mut();
    *n = 2;
}
```

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

### OpenOptions::create example

Source: https://docs.rs/tokio/1.49.0/src/tokio/fs/open_options.rs.html

Example usage of the create method to create a new file if it does not exist. Requires write or append access. The file is opened with write and create options.

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

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

    Ok(())
}
```

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

### len example: get number of messages in channel

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/mpsc/bounded.rs.html

Shows how to use len() to get the number of messages currently in the channel. The example creates a channel, asserts the length is 0, sends a message, and then asserts the length is 1.

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

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let (tx, rx) = mpsc::channel(10);
assert_eq!(0, rx.len());

tx.send(0).await.unwrap();
```

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

### set_quickack example

Source: https://docs.rs/tokio/1.49.0/tokio/net/struct.TcpStream.html

Connects to a peer and enables TCP_QUICKACK. Available on Linux or Android or Fuchsia or Cygwin only. Linux may reset this flag after further operations.

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

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

stream.set_quickack(true)?;
```

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

### sender_count example

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/watch.rs.html

Shows how to use sender_count to get the number of active senders. The example creates a channel, clones the sender, and asserts the count is 2.

```rust
let (tx, rx) = tokio::sync::watch::channel(true);
let tx2 = tx.clone();
assert_eq!(2, tx2.sender_count());
```

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

### open example

Source: https://docs.rs/tokio/1.49.0/tokio/fs/struct.OpenOptions.html

Opens a file with the specified options. Returns errors for various conditions such as NotFound, PermissionDenied, AlreadyExists, InvalidInput, and Other.

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

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

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

### take example: limit bytes read from file

Source: https://docs.rs/tokio/1.49.0/src/tokio/io/util/async_read_ext.rs.html

Example for the take method. It opens a file and creates a Take adaptor that limits reads to at most 5 bytes. The example is wrapped in a cfg to exclude wasm targets.

```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(())
}
```

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

### read_i16 usage example (partial)

Source: https://docs.rs/tokio/1.49.0/src/tokio/io/util/async_read_ext.rs.html

Starts reading two signed 16-bit big-endian integers from a Cursor. The example is cut off in the source, so the assertions and closing lines are not shown.

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

use std::io::Cursor;

# #[tokio::main(flavor = "current_thread")]
# async fn main() -> io::Result<()> {
let mut reader = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);
```

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

### Using UdpSocket::ready with Interest::READABLE | Interest::WRITABLE

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/udp.rs.html

Example for the ready method. Binds a UDP socket, connects to a peer, and loops on readiness events. Uses try_recv and try_send, handling WouldBlock as false positives. The buffer is not included in the async task and only exists on the stack.

```rust
use tokio::io::{self, Interest};
use tokio::net::UdpSocket;

#[tokio::main]
async fn main() -> io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:8080").await?;
    socket.connect("127.0.0.1:8081").await?;

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

        if ready.is_readable() {
            // The buffer is **not** included in the async task and will only exist
            // on the stack.
            let mut data = [0; 1024];
            match socket.try_recv(&mut data[..]) {
                Ok(n) => {
                    println!("received {:?}", &data[..n]);
                }
                // False-positive, continue
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                Err(e) => {
                    return Err(e);
                }
            }
        }

        if ready.is_writable() {
            // Write some data
            match socket.try_send(b"hello world") {
                Ok(n) => {
                    println!("sent {} bytes", n);
                }
                // False-positive, continue
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                Err(e) => {
                    return Err(e);
                }
            }
        }
    }
}
```

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

### Example: Using tokio::fs::create_dir_all

Source: https://docs.rs/tokio/1.49.0/src/tokio/fs/create_dir_all.rs.html

This example demonstrates how to use the async create_dir_all function. It is marked as no_run, meaning it is not executed during documentation tests. The function returns a Result and uses the ? operator to propagate errors.

```rust
use tokio::fs;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    fs::create_dir_all("/some/dir").await?;
    Ok(())
}

```

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

### Example: Using try_into_panic to get panic reason

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/task/error.rs.html

Example from the try_into_panic method documentation. Spawns a task that panics, awaits it, and if the error can be converted to a panic reason, resumes the panic on the main task. This example is marked should_panic and ignored on wasm.

```rust
use std::panic;

#[tokio::main]
async fn main() {
    let err = tokio::spawn(async {
        panic!("boom");
    }).await.unwrap_err();

    if let Ok(reason) = err.try_into_panic() {
        // Resume the panic on the main task
        panic::resume_unwind(reason);
    }
}
```

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

### MutexGuard::mutex example

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/mutex.rs.html

Shows how to use MutexGuard::mutex to get a reference to the original Mutex while holding a guard. The example unlocks and relocks the mutex by dropping the guard and then locking again.

```rust
use tokio::sync::{Mutex, MutexGuard};

async fn unlock_and_relock<'l>(guard: MutexGuard<'l, u32>) -> MutexGuard<'l, u32> {
    println!("1. contains: {:?}", *guard);
    let mutex = MutexGuard::mutex(&guard);
    drop(guard);
    let guard = mutex.lock().await;
    println!("2. contains: {:?}", *guard);
    guard
}
#
# #[tokio::main(flavor = "current_thread")]
# async fn main() {
```

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

### Using UnixDatagram::ready with Interest::READABLE | Interest::WRITABLE

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/unix/datagram/socket.rs.html

Example for the ready() method. It binds a Unix datagram socket, connects to a server, and loops waiting for both readable and writable readiness. Handles WouldBlock errors as false positives and continues.

```rust
use tokio::io::Interest;
use tokio::net::UnixDatagram;
use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
    let dir = tempfile::tempdir().unwrap();
    let client_path = dir.path().join("client.sock");
    let server_path = dir.path().join("server.sock");
    let socket = UnixDatagram::bind(&client_path)?;
    socket.connect(&server_path)?;

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

        if ready.is_readable() {
            let mut data = [0; 1024];
            match socket.try_recv(&mut data[..]) {
                Ok(n) => {
                    println!("received {:?}", &data[..n]);
                }
                // False-positive, continue
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                Err(e) => {
                    return Err(e);
                }
            }
        }

        if ready.is_writable() {
            // Write some data
            match socket.try_send(b"hello world") {
                Ok(n) => {
                    println!("sent {} bytes", n);
                }
                // False-positive, continue
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                Err(e) => {
                    return Err(e);
                }
            }
        }
    }
}
```

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

### Enable all drivers with enable_all

Source: https://docs.rs/tokio/1.49.0/tokio/runtime/struct.Builder.html

Example showing how to enable both I/O and time drivers using the enable_all method.

```rust
use tokio::runtime;

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

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

### Get number of histogram buckets for poll times

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/metrics/runtime.rs.html

Example for poll_time_histogram_num_buckets() showing how to get the number of histogram buckets tracking task poll times. Requires building the runtime with enable_metrics_poll_time_histogram().

```rust
use tokio::runtime::{self, Handle};

fn main() {
    runtime::Builder::new_current_thread()
        .enable_metrics_poll_time_histogram()
        .build()
        .unwrap()
        .block_on(async {
            let metrics = Handle::current().metrics();
            let buckets = metrics.poll_time_histogram_num_buckets();

            println!("Histogram buckets: {:?}", buckets);
        });
}
```

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

### MutexGuard::mutex method example

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/mutex.rs.html

Shows how to use MutexGuard::mutex to get a reference to the Mutex from a guard. The example is part of the method's documentation and uses a helper function unlock_and_relock.

```rust
/// #     let mutex = Mutex::new(0u32);
/// #     let guard = mutex.lock().await;
/// #     let _guard = unlock_and_relock(guard).await;
/// # }
/// ```
```

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

### Create and open a named pipe with ClientOptions::new()

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/windows/named_pipe.rs.html

Shows how to create a server and open a client named pipe. The server must be created before the client creation succeeds. Uses the default ClientOptions settings.

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

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

# #[tokio::main] async fn main() -> std::io::Result<()> {
// 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)?;
# Ok(()) }

```

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

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

Source: https://docs.rs/tokio/1.49.0/src/tokio/fs/open_options.rs.html

Shows how to open a file for both reading and writing, and create it if it doesn't exist, using `OpenOptions::new()`, `.read(true)`, `.write(true)`, `.create(true)`, and `.open("foo.txt")` inside a `#[tokio::main]` async main function.

```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 TCP_NODELAY option with nodelay()

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/tcp/stream.rs.html

Example for TcpStream::nodelay() that connects to a local server and prints the current value of the TCP_NODELAY option. The example is marked no_run and uses an async function.

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

# async fn dox() -> Result<(), Box<dyn std::error::Error>> {
let stream = TcpStream::connect("127.0.0.1:8080").await?;

println!("{:?}", stream.nodelay()?);
# Ok(())
# }
```

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

### Delay behavior example

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

Shows how to set MissedTickBehavior::Delay. Future ticks are scheduled at a regular period from when tick was called, not from start. Ticks are not shortened and may not align with multiples of 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;
```

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

### build

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/builder.rs.html

Creates the configured `Runtime` instance. The returned `Runtime` is ready to spawn tasks.

```APIDOC
## build

### Description
Creates the configured `Runtime` instance. The returned `Runtime` is ready to spawn tasks.

### Method
Builder method

### Signature
`pub fn build(&mut self) -> io::Result<Runtime>`

### Returns
- `io::Result<Runtime>` - The configured runtime, or an I/O error if building fails.

### Example
```rust
let rt = tokio::runtime::Builder::new_multi_thread().build().unwrap();
rt.block_on(async {
    println!("Hello from the Tokio runtime");
});
```
```

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

### take_error example: retrieve SO_ERROR from UdpSocket

Source: https://docs.rs/tokio/1.49.0/tokio/net/struct.UdpSocket.html

Shows how to call take_error() on a UdpSocket to get the SO_ERROR option value. The example binds to 0.0.0.0:8080 and prints the error if present. Available on non-loom and non-WASI platforms.

```rust
use tokio::net::UdpSocket;
use std::io;

#[tokio::main]
async fn main() -> io::Result<()> {
    // Create a socket
    let socket = UdpSocket::bind("0.0.0.0:8080").await?;

    if let Ok(Some(err)) = socket.take_error() {
        println!("Got error: {:?}", err);
    }

    Ok(())
}
```

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

### Get number of workers with RuntimeMetrics::num_workers

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/metrics/runtime.rs.html

Example from the num_workers method documentation. Uses Handle::current().metrics() to obtain a RuntimeMetrics handle and prints the number of workers. The example is wrapped in a current_thread Tokio runtime.

```rust
use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.num_workers();
println!("Runtime is using {} workers", n);
# }

```

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

### Example usage of create_dir_all

Source: https://docs.rs/tokio/1.49.0/tokio/fs/fn.create_dir_all.html

Example demonstrating how to use tokio::fs::create_dir_all within a tokio main function. It creates the directory '/some/dir' and propagates any I/O error.

```rust
use tokio::fs;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    fs::create_dir_all("/some/dir").await?;
    Ok(())
}
```

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

### Create OpenOptions and open a file without awaiting

Source: https://docs.rs/tokio/1.49.0/src/tokio/fs/open_options.rs.html

Shows creating an `OpenOptions` instance and calling `.read(true).open("foo.txt")` to obtain a future without awaiting it. This is a non-async example.

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

let mut options = OpenOptions::new();
let future = options.read(true).open("foo.txt");
```

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

### Remove interests with Interest::remove

Source: https://docs.rs/tokio/1.49.0/src/tokio/io/interest.rs.html

Shows how to use the remove method to remove interests from a set. The example removes READABLE from a combined interest, then removes WRITABLE to get None, and finally removes all interests at once to get None.

```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: Create a pipe and pass writing end to a spawned process

Source: https://docs.rs/tokio/1.49.0/tokio/net/unix/pipe/fn.pipe.html

Creates a pipe, passes the writing end to a spawned `echo` command, and reads the output. Uses `pipe::pipe()`, `tx.into_blocking_fd()`, and `rx.read_to_string()`. The example asserts the command succeeds and the buffer equals "Hello, world!\n".

```rust
use tokio::net::unix::pipe;
use tokio::process::Command;

let (tx, mut rx) = pipe::pipe()?;
let mut buffer = String::new();

let status = Command::new("echo")
    .arg("Hello, world!")
    .stdout(tx.into_blocking_fd()?)
    .status();
rx.read_to_string(&mut buffer).await?;

assert!(status.await?.success());
assert_eq!(buffer, "Hello, world!\n");
```

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

### Get number of alive tasks with RuntimeMetrics::num_alive_tasks

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/metrics/runtime.rs.html

Example from the num_alive_tasks method documentation. Uses Handle::current().metrics() to obtain a RuntimeMetrics handle and prints the number of alive tasks. The example is wrapped in a current_thread Tokio runtime.

```rust
use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.num_alive_tasks();
println!("Runtime has {} alive tasks", n);
# }

```

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

### Example: watch channel usage printing 'hello! world!'

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

Example from the documentation that creates a watch channel with initial value "hello", spawns a task that loops to print the current value and waits for changes, then sends "world" after a short delay. The loop uses `borrow_and_update` and `changed` to process the initial value before awaiting changes.

```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")?;
```

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

### Bind and accept connections with UnixListener

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/unix/listener.rs.html

Example from the UnixListener documentation showing how to bind to a socket path and accept connections in a loop. The accept method returns a stream and address, and errors are handled in the match. This example is marked no_run.

```rust
use tokio::net::UnixListener;

#[tokio::main]
async fn main() {
    let listener = UnixListener::bind("/path/to/the/socket").unwrap();
    loop {
        match listener.accept().await {
            Ok((stream, _addr)) => {
                println!("new client!");
            }
            Err(e) => { /* connection failed */ }
        }
    }
}

```

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

### Create and use a oneshot channel

Source: https://docs.rs/tokio/1.49.0/src/tokio/sync/oneshot.rs.html

Example from the documentation showing how to create a oneshot channel, send a value, and receive it. The example is incomplete in the source, with the receiver and sender setup omitted, but the visible code shows the send and receive operations.

```rust
///         }
///     }
/// }
/// # handle.await.unwrap();
/// # }
/// ```
```

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

### Example: using broadcast::channel and subscribe

Source: https://docs.rs/tokio/1.49.0/tokio/sync/broadcast/fn.channel.html

Example demonstrating creating a broadcast channel with capacity 16, subscribing a second receiver, and sending values that are received by both receivers. Panics if `capacity` is 0.

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

let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();

tokio::spawn(async move {
    assert_eq!(rx1.recv().await.unwrap(), 10);
    assert_eq!(rx1.recv().await.unwrap(), 20);
});

tokio::spawn(async move {
    assert_eq!(rx2.recv().await.unwrap(), 10);
    assert_eq!(rx2.recv().await.unwrap(), 20);
});

tx.send(10).unwrap();
tx.send(20).unwrap();
```

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

### Example: Unify reader and writer with simplex

Source: https://docs.rs/tokio/1.49.0/tokio/io/fn.simplex.html

Shows how to create a simplex stream, unify the reader and writer halves using unsplit, and perform async write and read operations. The example writes 'hello' and reads it back, asserting equality.

```rust
let (reader, writer) = tokio::io::simplex(64);
let mut simplex_stream = reader.unsplit(writer);
simplex_stream.write_all(b"hello").await?;

let mut buf = [0u8; 5];
simplex_stream.read_exact(&mut buf).await?;
assert_eq!(&buf, b"hello");
```

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

### Get peer address of a TcpStream

Source: https://docs.rs/tokio/1.49.0/tokio/net/struct.TcpStream.html

Example for peer_addr: connects to a peer and prints the remote address. Requires the 'net' feature.

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

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

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

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

### Get local address of a TcpStream

Source: https://docs.rs/tokio/1.49.0/tokio/net/struct.TcpStream.html

Example for local_addr: connects to a peer and prints the local address. Requires the 'net' feature.

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

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

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

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

### Accept connections with TcpListener::accept

Source: https://docs.rs/tokio/1.49.0/src/tokio/net/tcp/listener.rs.html

Shows how to bind a TcpListener to an address and accept incoming connections in a loop. The example uses #[tokio::main] and handles errors with io::Result. Note that accepting can lead to various errors, not all fatal.

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

use std::io;

async fn process_socket<T>(socket: T) {
    # drop(socket);
    // do work with socket here
}

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

    loop {
        let (socket, _) = listener.accept().await?;
        process_socket(socket).await;
    }
}
```

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

### LocalRuntime::new example

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/local_runtime/runtime.rs.html

Creates a new `LocalRuntime` with default configuration values, initializing the scheduler, I/O driver, and time driver. Returns a `std::io::Result`.

```rust
use tokio::runtime::LocalRuntime;

let rt = LocalRuntime::new()
    .unwrap();

// Use the runtime...
```

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

### Get worker park/unpark count and determine worker state

Source: https://docs.rs/tokio/1.49.0/src/tokio/runtime/metrics/runtime.rs.html

Example for worker_park_unpark_count. It retrieves the park/unpark count for worker 0 and prints whether the worker is active or parked based on the parity of the count. The example is wrapped in a current_thread Tokio runtime.

```rust
use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();
let n = metrics.worker_park_unpark_count(0);

println!("worker 0 parked and unparked {} times", n);

if n % 2 == 0 {
    println!("worker 0 is active");
} else {
    println!("worker 0 is parked");
}
# }

```
Tokens:
Raw