#day #hyperlane #language #format #web-programming #networking #time

recoverable-spawn

A thread that supports automatic recovery from panics, allowing threads to restart after a panic. Useful for resilient and fault-tolerant concurrency in network and web programming.

27 releases (15 stable)

new 3.4.3 Mar 11, 2025
3.4.1 Feb 9, 2025
2.0.0 Jan 11, 2025
1.0.0 Jan 10, 2025
0.8.0 Jan 10, 2025

#920 in Network programming

Download history 1111/week @ 2025-01-07 807/week @ 2025-01-14 219/week @ 2025-01-21 18/week @ 2025-01-28 278/week @ 2025-02-04 254/week @ 2025-02-11 158/week @ 2025-02-18 386/week @ 2025-02-25 148/week @ 2025-03-04

984 downloads per month
Used in 6 crates (5 directly)

MIT license

33KB
389 lines

recoverable-spawn

Official Documentation

Api Docs

A thread that supports automatic recovery from panics, allowing threads to restart after a panic. Useful for resilient and fault-tolerant concurrency in network and web programming.

Installation

To use this crate, you can run cmd:

cargo add recoverable-spawn

Use

recoverable_spawn

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = recoverable_spawn(move || {
    panic!("{}", msg);
});
let _ = handle.join();
let handle: JoinHandle<()> = recoverable_spawn_with_error_handle(
    move || {
        panic!("{}", msg);
    },
    |err| {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

recoverable_spawn_with_error_handle

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = recoverable_spawn_with_error_handle(
    move || {
        panic!("{}", msg);
    },
    |err| {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

async_recoverable_spawn

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn(move || async move {
    panic!("{}", msg);
});
let _ = handle.join();

async_recoverable_spawn_catch

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn_catch(
    move || async move {
        panic!("{}", msg);
    },
    move |err| async move {
        println!("handle error => {}", err);
    },
);
let _ = handle.join();

async_recoverable_spawn_catch_finally

use recoverable_spawn::*;
let msg: &str = "test";
let handle: JoinHandle<()> = async_recoverable_spawn_catch_finally(
    move || async move {
        panic!("{}", msg);
    },
    move |err| async move {
        println!("handle error => {}", err);
        panic!("{}", err);
    },
    move || async move {
        println!("finally");
    },
);
let _ = handle.join();

License

This project is licensed under the MIT License. See the LICENSE file for details.

Contributing

Contributions are welcome! Please open an issue or submit a pull request.

Contact

For any inquiries, please reach out to the author at ltpp-universe root@ltpp.vip.

Dependencies

~2.4–8MB
~58K SLoC