Rocket is doing the state handling and moved to RwLock.

It's actually working fine performance wise, it was a bug in my testing.

src/main.rs

@@ -1,103 +1,22 @@
-use dashmap::DashMap;
-use once_cell::sync::{Lazy};
 use rocket::State;
-use std::{sync::{RwLock}, collections::{VecDeque}};
-
-
-
+use std::{sync::RwLock, collections::{VecDeque, HashMap}};
 
 #[derive(Debug)]
 struct DumbQueue {
-    queue_map : RwLock<DashMap<String, usize>>,
+    queue_map : RwLock<HashMap<String, usize>>,
     queues : RwLock<Vec<RwLock<VecDeque<String>>>>,
-    current_queue : usize,
 }
 
 
 impl DumbQueue {
     fn new() -> Self {
         DumbQueue { 
-            queue_map: RwLock::new(DashMap::new()),
+            queue_map: RwLock::new(HashMap::new()),
             queues: RwLock::new(vec!()),
-            current_queue: 0,
-        }
-    }
-
-
-    fn push_back(&mut self, key: String, val: String) {
-        
-        let lookup_key = key.clone();
-        
-        let value = val.clone().to_string();
-
-        let queue_map = &self.queue_map;
-
-        match queue_map.read().unwrap().get(&lookup_key) {
-            None => {
-                let new_queue = RwLock::new(VecDeque::new());
-                self.queues.write().unwrap().push(new_queue);
-                let _ = &self.queue_map.write().unwrap().insert(key.to_string(), self.current_queue as usize);
-                self.queues.read().unwrap()[self.current_queue].write().unwrap().push_back(value);
-                self.current_queue += 1;
-            },
-            Some(i) => {
-                self.queues.read().unwrap()[*i].write().unwrap().push_back(value); 
-            }
-        }
-    }
-
-    fn pop_front(&mut self, key: String) -> Option<String> {
-        let val_key = key;
-        let queue_map = &self.queue_map;
-        match queue_map.read().unwrap().get(val_key.as_str()) {
-            Some(i) => {
-                let index : usize = *i;
-                match self.queues.read().unwrap()[index]
-                        .write().unwrap().pop_front() {
-                    Some(res) => return Some(res),
-                    None => None
-                }
-            }
-            None => None
         }
     }
 }
 
-struct DumberQueue {
-    queue_map : RwLock<DashMap<String, usize>>,
-}
-
-impl DumberQueue {
-    fn new() -> Self {
-        DumberQueue { 
-            queue_map: RwLock::new(DashMap::new()),
-        }
-    }
-
-    fn get_bearings(&self, key: String) {
-        
-    }
-
-    fn push_back(&mut self, key: String, val: String) {
-        
-    }
-
-    fn pop_front(&mut self, key: String) -> Option<String> {
-        let val_key = key;
-        let queue_map = &self.queue_map;
-        match queue_map.read().unwrap().get(val_key.as_str()) {
-            Some(i) => {
-                let index : usize = *i;
-                match self.queues.read().unwrap()[index]
-                        .write().unwrap().pop_front() {
-                    Some(res) => return Some(res),
-                    None => None
-                }
-            }
-            None => None
-        }
-    }
-}
 
 #[macro_use] extern crate rocket;
 
@@ -108,26 +27,63 @@ fn index() -> &'static str {
 
 
 #[get("/<id>")]
-fn get_by_id(id: String, dumb_queue: &State<DumbQueue>) -> String {
+fn get_by_id(id: &str, dumb_queue: &State<DumbQueue>) -> String {
     
-    let result = match dumb_queue.pop_front(id) {
-        Some(res) => res.to_string(),
+    let queue_map = &dumb_queue.queue_map;
+    let queues = &dumb_queue.queues;
+    match queue_map.read().unwrap().get(id) {
+        Some(i) => {
+            match queues.read().unwrap()[*i]
+                    .write().unwrap().pop_front() {
+                Some(res) => return res,
+                None => String::from("")
+            }
+        }
         None => String::from("")
-    };
-    result
+    }
 }
 
 #[put("/<id>", data = "<input>")]
-fn put_by_id(id: String, input: String, dumb_queue: &State<DumbQueue>) {
-    dumb_queue.push_back(id, input);
+fn put_by_id(id: &str, input: &str, dumb_queue: &State<DumbQueue>) {
+    
+    let queue_map = &dumb_queue.queue_map;
+    let queues = &dumb_queue.queues;
+    let mut inserted = false;
+    let mut inserted_index = usize::MAX;
+
+    let map_read = queue_map.read().unwrap();
+    
+    match map_read.get(&id.to_string()) {
+        None => {
+            let new_queue = RwLock::new(VecDeque::with_capacity(1024));
+            let mut write = new_queue.write().unwrap();
+            write.push_back(input.to_string());
+            drop(write);
+            
+            let mut write = queues.write().unwrap();
+            write.push(new_queue); 
+            inserted_index = write.len() -1 as usize;
+            drop(write);
+            inserted = true;
+        },
+        Some(i) => {
+            let read = queues.read().unwrap();
+            read[*i].write().unwrap().push_back(input.to_string()); 
+        }
+    }
+    drop(map_read);
+
+    if inserted {
+        let mut write = queue_map.write().unwrap();
+        write.insert(id.to_string(), inserted_index);
+        drop(write);
+    }
 }
 
+
 #[launch]
 fn rocket() -> _ {
-
 //    let dumb_queue : DumbQueue = DumbQueue::new();
-
-
     rocket::build()
         .manage( DumbQueue::new())
         .mount("/", routes![index, put_by_id, get_by_id])