Is it safe to .clone() across threads?

[jjangga0214]

Let's say I have connections in deadpool.
I have total deadpool_max_size connections.

let pool: Pool<AsyncPgConnection> = Pool::builder(deadpool_config)
    .max_size(deadpool_max_size)
    .build()
    .unwrap();

And I have to share the pool across multiple arbitrary number of async threads.

// share the pool with async thread
let _pool = pool.clone();
tokio::spawn(async move { 
    let mut conn = _pool.get().await.unwrap();
    // ... using conn
});

// and another different async thread
let _pool = pool.clone();
tokio::spawn(async move { 
    let mut conn = _pool.get().await.unwrap();
    // ... using conn
});
 
// and so on...
// let _pool = pool.clone(); 
// tokio::spawn(async move { .......

I want the number of connections the entire rust program generates in total must be less than or equal to deadpool_max_size at any time.

In the example above, I didn't wrapped the pool with Arc, Mutex, or RwLock.
But just used the pure .clone() directly.
The reason was that I saw there's already Arc field in the type.

Is this example suitable to satisfy my intention?

Thanks.

[weiznich]

To cite from the relevant documentation

This struct can be cloned and transferred across thread boundaries and uses reference counting for its internal state.

So yes, it's safe to use it in that way. (Otherwise either the implementation would be unsound or the compiler would complain)

[jjangga0214]

@weiznich Thanks for the reply.

let pool: Pool<AsyncPgConnection> = Pool::builder(deadpool_config)
    .max_size(2) // <== max size is 2
    .build()
    .unwrap();

let _pool = pool.clone();
tokio::spawn(async move { 
    for i in 0..3 {
        let mut conn = _pool.get().await.unwrap();
         // This works when i == 0 or 1, but not when i == 2
        do_something(&mut conn);
    }
});

So it seems like drop(conn) is automatically called at the end of each iteration, and the Pool becomes out of connections.
How can I get it to work?

Thank you.

[weiznich]

That's a deadpool question, not a diesel_async question. You might want to use their support channels to get an answer for this. Otherwise this is likely just the desired behavior as if you limit the pool size to a certain number that means that you don't get more connections that this number at the same time.

[jjangga0214]

Actually, the cause was differentl, but it was totally by my subtle mistake. Thank you for the reply anyway!