Does it represent different threads if call StreamSink API multiple times?

[dbsxdbsx]

For example, there is a stream API:

#[tokio::main(flavor = "current_thread")]
pub async fn call_stream(
    path: String,
    listener: StreamSink<String>,
) -> anyhow::Result<()> {
Loop{
...
}
}

Then, if this API is called multiple times, say 2 times, does it mean that there are 2 independent threads running backstage?

Since I need multiple streams, but with the same routines of different parameters, I wonder if I need to create the same API multiple times.

[fzyzcjy]

does it mean that there are 2 independent threads running backstage?

If you are using default executor I guess it is a thread pool. So if that loop does not terminate it does occupy one thread per function call.

But since you are using async I am not sure.

Maybe make a simple experiment: println! current thread name inside that loop etc.

[dbsxdbsx]

does it mean that there are 2 independent threads running backstage?

If you are using default executor I guess it is a thread pool. So if that loop does not terminate it does occupy one thread per function call.

But since you are using async I am not sure.

Maybe make a simple experiment: println! current thread name inside that loop etc.

My code is roughly like this:

#[tokio::main(flavor = "current_thread")]
pub async fn call_stream(
    path: String,
    listener: StreamSink<String>,
) -> anyhow::Result<()> {
debug!("stream API thread id：{:?}", thread::current().id());
let reader_task = tokio::spawn(async move {
            loop {
debug!("reader thread id：{:?}", thread::current().id());
if xxx.await{
//send feedback to dart
}
}
...
}

let writer_task = tokio::spawn(async move {
            loop {
debug!("writer thread id：{:?}", thread::current().id());
if yyy{
//do something
}
}
...
}

}

After testing, I found:
With macro #[tokio::main(flavor = "current_thread")], reader、writer and the stream API threads are always the same;
With macro #[tokio::main], reader、writer and the stream API thread are always different, and the threads are probably green threads since I only got 8 logic CPUs, but the thread id could be greater than 43;
Regardless of either macro stated above, I didn't notice thread conflicts among reader、writer and stream API respectively.
In my case, with macro #[tokio::main(flavor = "current_thread")], the reader_task would be stuck, and meanwhile the feedback from it is slower than using #[tokio::main].

[fzyzcjy]

Looks good!