Refactor synchronized with concurrent collections

src/main/java/com/spotifyremastered/server/SpotifyManager.java

@@ -2,29 +2,28 @@
 
 import com.spotifyremastered.server.music.MusicManager;
 import com.spotifyremastered.server.user.UserManager;
+
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class SpotifyManager {
 
     private final UserManager userManager;
     private final MusicManager musicManager;
-    private final Map<Client, Integer> portsManager;
-    private final Object lock = new Object();
+    private final Map<Client, Integer> portsManager = new ConcurrentHashMap<>();
 
     private static final short FIRST_AVAILABLE_PORT = 1338;
     private static final short MAX_PORTS = 1000;
 
     public SpotifyManager() {
         this.userManager = new UserManager(new HashMap<>(), new HashMap<>(), UserManager.USER_DATA_FILE_PATH);
         this.musicManager = new MusicManager();
-        this.portsManager = new HashMap<>();
     }
 
     public SpotifyManager(UserManager userManager, MusicManager musicManager) {
         this.userManager = userManager;
         this.musicManager = musicManager;
-        this.portsManager = new HashMap<>();
     }
 
     public UserManager getUserManager() {
@@ -36,39 +35,38 @@ public MusicManager getMusicManager() {
     }
 
     public Map<Client, Integer> getPortsManager() {
-        synchronized (lock) {
-            return new HashMap<>(portsManager);
-        }
+        return Map.copyOf(portsManager);
     }
 
     public int getNewPort(Client client) {
-        synchronized (lock) {
-            int maxPort = FIRST_AVAILABLE_PORT + MAX_PORTS;
-            for (int i = FIRST_AVAILABLE_PORT; i < maxPort; i++) {
-                if (isPortAvailable(i)) {
-                    portsManager.put(client, i);
+        Integer existingPort = portsManager.get(client);
+        if (existingPort != null) {
+            return existingPort;
+        }
+
+        int maxPort = FIRST_AVAILABLE_PORT + MAX_PORTS;
+        for (int i = FIRST_AVAILABLE_PORT; i < maxPort; i++) {
+            if (isPortAvailable(i)) {
+                Integer previous = portsManager.putIfAbsent(client, i);
+                if (previous == null) {
                     return i;
+                } else {
+                    return previous;
                 }
             }
-            throw new RuntimeException("No available ports");
         }
+        throw new RuntimeException("No available ports");
     }
 
     public void removePort(Client client) {
-        synchronized (lock) {
-            portsManager.remove(client);
-        }
+        portsManager.remove(client);
     }
 
     public boolean isPortAvailable(int port) {
-        synchronized (lock) {
-            return !portsManager.containsValue(port);
-        }
+        return !portsManager.containsValue(port);
     }
 
     public boolean isPortAvailable(Client client) {
-        synchronized (lock) {
-            return portsManager.containsValue(portsManager.get(client));
-        }
+        return portsManager.containsKey(client);
     }
 }

src/main/java/com/spotifyremastered/server/SpotifyServer.java

@@ -18,6 +18,7 @@
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class SpotifyServer {
 
@@ -28,10 +29,9 @@ public class SpotifyServer {
     private static boolean online = true;
 
     private final SpotifyManager spotifyManager;
-    private final Map<SocketChannel, Client> clients;
+    private final Map<SocketChannel, Client> clients = new ConcurrentHashMap<>();
 
     public SpotifyServer() {
-        this.clients = new HashMap<>();
         this.spotifyManager = new SpotifyManager();
     }