Remove mutex

src/pool/connection.rs

@@ -31,14 +31,11 @@ impl Drop for RedisConnection {
         if self.connection.is_some() && self.pool.is_some() {
             let shared = self.pool.take().unwrap();
             let connection = self.connection.take().unwrap();
-            {
-                let pool = shared.pool.blocking_lock();
 
-                if pool.len() < pool.capacity() {
-                    // pool has space lets insert it back into the Pool
-                    if pool.push(connection).is_err() {
-                        panic!("Queue was maxed out");
-                    }
+            if shared.pool.len() < shared.pool.capacity() {
+                // pool has space lets insert it back into the Pool
+                if shared.pool.push(connection).is_err() {
+                    panic!("Queue was maxed out");
                 }
             }
         }

src/pool/shared.rs

@@ -3,17 +3,16 @@ use crate::RedisError;
 use crossbeam_queue::ArrayQueue;
 pub use redis::{aio::Connection, Client};
 use std::sync::Arc;
-use tokio::sync::Mutex;
 
 pub(crate) struct SharedPool {
-    pub(crate) pool: Mutex<ArrayQueue<Connection>>,
+    pub(crate) pool: ArrayQueue<Connection>,
     pub(crate) client: Client,
 }
 
 impl SharedPool {
     pub(crate) fn new_arc(client: Client, limit: u32) -> Arc<Self> {
         let pool = Self {
-            pool: Mutex::new(ArrayQueue::new(limit as usize)),
+            pool: ArrayQueue::new(limit as usize),
             client,
         };
 
@@ -22,9 +21,7 @@ impl SharedPool {
 
     pub(crate) async fn aquire(self: Arc<Self>) -> Result<RedisConnection, RedisError> {
         {
-            let pool = self.pool.lock().await;
-
-            if let Some(connection) = pool.pop() {
+            if let Some(connection) = self.pool.pop() {
                 return Ok(RedisConnection::new(Arc::clone(&self), connection));
             }
         }