mobc_redis

```rust use mobc::futures::channel::mpsc; use mobc::futures::compat::Future01CompatExt; use mobc::futures::prelude::*; use mobc::runtime::DefaultExecutor; use mobc::Error; use mobc::Pool; use mobcredis::redis::{self, RedisError}; use mobcredis::RedisConnectionManager; use std::time::Instant;

const MAX: usize = 5000;

async fn singlerequest( pool: Pool>, mut sender: mpsc::Sender<()>, ) -> Result<(), Error> { let mut conn = pool.get().await?; let rawredisconn = conn.takeraw_conn();

let (raw_redis_conn, pong) = redis::cmd("PING")
    .query_async::<_, String>(raw_redis_conn)
    .compat()
    .await?;

conn.set_raw_conn(raw_redis_conn);

assert_eq!("PONG", pong);
sender.send(()).await.unwrap();
Ok(())

}

async fn doredis(sender: mpsc::Sender<()>) -> Result<(), Error> { let client = redis::Client::open("redis://127.0.0.1").unwrap(); let manager = RedisConnectionManager::new(client); let pool = Pool::builder().maxsize(40).build(manager).await?;

for _ in 0..MAX {
    let pool = pool.clone();
    let tx = sender.clone();
    tokio::spawn(single_request(pool, tx).map(|_| ()));
}
Ok(())

}

[tokio::main]

async fn main() { envlogger::init(); let mark = Instant::now(); let (tx, mut rx) = mpsc::channel::<()>(MAX); doredis(tx).await.unwrap();

let mut num: usize = 0;
while let Some(_) = rx.next().await {
    num += 1;
    if num == MAX {
        break;
    }
}

println!("cost {:?}", mark.elapsed());

}

```