Designing a Thread-Safe Game Leaderboard Using ConcurrentSkipListMap

Welcome back! In our previous lesson, we explored how to implement a concurrent inventory system using ConcurrentHashMap . Today, we will take your skills further by designing a real-time, thread-safe game leaderboard using ConcurrentSkipListMap . This lesson will help you understand how to manage sorted data in a concurrent environment—an essential feature for real-time applications such as online games or financial systems.

What You'll Learn

By the end of this lesson, you will: Understand how ConcurrentSkipListMap maintains sorted data in a thread-safe manner. Learn how to update entries safely while handling concurrent modifications. Retrieve top-scoring entries efficiently, which is crucial for leaderboard management. These skills will ensure you are well-equipped to handle concurrent data access challenges in applications that require real-time data sorting and updates. Let’s dive in and start building our concurrent game leaderboard!

Recap: Understanding ConcurrentSkipListMap

Before we start implementing the leaderboard, let's quickly recap ConcurrentSkipListMap and why it's well-suited for our use case. ConcurrentSkipListMap is part of Java's java.util.concurrent package and is a thread-safe variant of TreeMap . It maintains keys in a sorted order and allows efficient retrieval of data in real time. One of the primary reasons to use ConcurrentSkipListMap is that it provides thread-safe access to the elements while ensuring that the entries are always sorted by key. This makes it ideal for use cases like leaderboards, where you want to maintain a ranking of players by score and allow concurrent updates. Thread Safety : Unlike traditional collections, ConcurrentSkipListMap allows multiple threads to update the map without the need for explicit synchronization or locking. Sorted Order : The map automatically sorts entries based on keys (in our case, player scores), making it easy to retrieve the highest-scoring players. However, by default, ConcurrentSkipListMap sorts the keys in ascending order . Since we want the leaderboard to rank players with the highest scores first, we need to modify the natural ordering.

Adjusting the Sorting Order with reverseOrder()

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Java

private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
    new ConcurrentSkipListMap<>(Collections.reverseOrder());

private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
    new ConcurrentSkipListMap<>(Collections.reverseOrder());

Java

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();
}

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();
}

Java

public void addScore(String player, double score) {
    Double oldScore = playerScores.put(player, score);
    if (oldScore != null) {
        // Remove player from old score set
        scoreMap.computeIfPresent(oldScore, (k, v) -> {
            v.remove(player);
            return v.isEmpty() ? null : v;
        });
    }
    // Add player to new score set
    scoreMap.compute(score, (k, v) -> {
        if (v == null) v = ConcurrentHashMap.newKeySet();
        v.add(player);
        return v;
    });
}

public void addScore(String player, double score) {
    Double oldScore = playerScores.put(player, score);
    if (oldScore != null) {
        // Remove player from old score set
        scoreMap.computeIfPresent(oldScore, (k, v) -> {
            v.remove(player);
            return v.isEmpty() ? null : v;
        });
    }
    // Add player to new score set
    scoreMap.compute(score, (k, v) -> {
        if (v == null) v = ConcurrentHashMap.newKeySet();
        v.add(player);
        return v;
    });
}

Java

playerScores.compute(player, (p, oldScore) -> {
    if (Objects.equals(oldScore, newScore)) return oldScore; // no change

    if (oldScore != null) {
        scoreMap.computeIfPresent(oldScore, (score, set) -> {
            set.remove(player);
            return set.isEmpty() ? null : set;
        });
    }

    scoreMap.compute(newScore, (score, set) -> {
        if (set == null) set = ConcurrentHashMap.newKeySet();
        set.add(player);
        return set;
    });

    return newScore;
});

playerScores.compute(player, (p, oldScore) -> {
    if (Objects.equals(oldScore, newScore)) return oldScore; // no change

    if (oldScore != null) {
        scoreMap.computeIfPresent(oldScore, (score, set) -> {
            set.remove(player);
            return set.isEmpty() ? null : set;
        });
    }

    scoreMap.compute(newScore, (score, set) -> {
        if (set == null) set = ConcurrentHashMap.newKeySet();
        set.add(player);
        return set;
    });

    return newScore;
});

Java

public List<String> getTopNPlayers(int n) {
    List<String> topPlayers = new ArrayList<>();
    for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
        for (String player : entry.getValue()) {
            topPlayers.add(player);
            if (topPlayers.size() == n) return topPlayers;
        }
    }
    return topPlayers;
}

public List<String> getTopNPlayers(int n) {
    List<String> topPlayers = new ArrayList<>();
    for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
        for (String player : entry.getValue()) {
            topPlayers.add(player);
            if (topPlayers.size() == n) return topPlayers;
        }
    }
    return topPlayers;
}

Java

public void displayLeaderboard() {
    scoreMap.forEach((score, players) ->
        players.forEach(player ->
            System.out.println(player + ": " + score)));
}

public void displayLeaderboard() {
    scoreMap.forEach((score, players) ->
        players.forEach(player ->
            System.out.println(player + ": " + score)));
}

Java

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();

    // Add or update a player's score
    public void addScore(String player, double score) {
        Double oldScore = playerScores.put(player, score);
        if (oldScore != null) {
            // Remove player from old score set
            scoreMap.computeIfPresent(oldScore, (k, v) -> {
                v.remove(player);
                return v.isEmpty() ? null : v;
            });
        }
        // Add player to new score set
        scoreMap.compute(score, (k, v) -> {
            if (v == null) v = ConcurrentHashMap.newKeySet();
            v.add(player);
            return v;
        });
    }

    // Get the top n players
    public List<String> getTopNPlayers(int n) {
        List<String> topPlayers = new ArrayList<>();
        for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
            for (String player : entry.getValue()) {
                topPlayers.add(player);
                if (topPlayers.size() == n) return topPlayers;
            }
        }
        return topPlayers;
    }

    // Display the entire leaderboard
    public void displayLeaderboard() {
        scoreMap.forEach((score, players) ->
            players.forEach(player ->
                System.out.println(player + ": " + score)));
    }
}

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();

    // Add or update a player's score
    public void addScore(String player, double score) {
        Double oldScore = playerScores.put(player, score);
        if (oldScore != null) {
            // Remove player from old score set
            scoreMap.computeIfPresent(oldScore, (k, v) -> {
                v.remove(player);
                return v.isEmpty() ? null : v;
            });
        }
        // Add player to new score set
        scoreMap.compute(score, (k, v) -> {
            if (v == null) v = ConcurrentHashMap.newKeySet();
            v.add(player);
            return v;
        });
    }

    // Get the top n players
    public List<String> getTopNPlayers(int n) {
        List<String> topPlayers = new ArrayList<>();
        for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
            for (String player : entry.getValue()) {
                topPlayers.add(player);
                if (topPlayers.size() == n) return topPlayers;
            }
        }
        return topPlayers;
    }

    // Display the entire leaderboard
    public void displayLeaderboard() {
        scoreMap.forEach((score, players) ->
            players.forEach(player ->
                System.out.println(player + ": " + score)));
    }
}

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Leaderboard leaderboard = new Leaderboard();

        // Thread 1 - Adding scores for group 1 of players
        Thread t1 = new Thread(() -> {
            leaderboard.addScore("Alice", 1500);
            leaderboard.addScore("Bob", 1200);
        });

        // Thread 2 - Adding scores for group 2 of players
        Thread t2 = new Thread(() -> {
            leaderboard.addScore("Charlie", 1800);
            leaderboard.addScore("Diana", 1600);
        });

        // Thread 3 - Updating existing scores
        Thread t3 = new Thread(() -> {
            leaderboard.addScore("Alice", 1900);
            leaderboard.addScore("Eve", 1700);
        });

        // Start the threads
        t1.start();
        t2.start();
        t3.start();

        // Wait for all threads to finish
        t1.join();
        t2.join();
        t3.join();

        // Display the final leaderboard
        System.out.println("=== Final Leaderboard ===");
        leaderboard.displayLeaderboard();

        // Display the top 3 players
        System.out.println("\n=== Top 3 Players ===");
        leaderboard.getTopNPlayers(3).forEach(player -> System.out.println(player));
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Leaderboard leaderboard = new Leaderboard();

        // Thread 1 - Adding scores for group 1 of players
        Thread t1 = new Thread(() -> {
            leaderboard.addScore("Alice", 1500);
            leaderboard.addScore("Bob", 1200);
        });

        // Thread 2 - Adding scores for group 2 of players
        Thread t2 = new Thread(() -> {
            leaderboard.addScore("Charlie", 1800);
            leaderboard.addScore("Diana", 1600);
        });

        // Thread 3 - Updating existing scores
        Thread t3 = new Thread(() -> {
            leaderboard.addScore("Alice", 1900);
            leaderboard.addScore("Eve", 1700);
        });

        // Start the threads
        t1.start();
        t2.start();
        t3.start();

        // Wait for all threads to finish
        t1.join();
        t2.join();
        t3.join();

        // Display the final leaderboard
        System.out.println("=== Final Leaderboard ===");
        leaderboard.displayLeaderboard();

        // Display the top 3 players
        System.out.println("\n=== Top 3 Players ===");
        leaderboard.getTopNPlayers(3).forEach(player -> System.out.println(player));
    }
}

Java

private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
    new ConcurrentSkipListMap<>(Collections.reverseOrder());

Java

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();
}

Java

public void addScore(String player, double score) {
    Double oldScore = playerScores.put(player, score);
    if (oldScore != null) {
        // Remove player from old score set
        scoreMap.computeIfPresent(oldScore, (k, v) -> {
            v.remove(player);
            return v.isEmpty() ? null : v;
        });
    }
    // Add player to new score set
    scoreMap.compute(score, (k, v) -> {
        if (v == null) v = ConcurrentHashMap.newKeySet();
        v.add(player);
        return v;
    });
}

Java

playerScores.compute(player, (p, oldScore) -> {
    if (Objects.equals(oldScore, newScore)) return oldScore; // no change

    if (oldScore != null) {
        scoreMap.computeIfPresent(oldScore, (score, set) -> {
            set.remove(player);
            return set.isEmpty() ? null : set;
        });
    }

    scoreMap.compute(newScore, (score, set) -> {
        if (set == null) set = ConcurrentHashMap.newKeySet();
        set.add(player);
        return set;
    });

    return newScore;
});

Java

public List<String> getTopNPlayers(int n) {
    List<String> topPlayers = new ArrayList<>();
    for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
        for (String player : entry.getValue()) {
            topPlayers.add(player);
            if (topPlayers.size() == n) return topPlayers;
        }
    }
    return topPlayers;
}

Java

public void displayLeaderboard() {
    scoreMap.forEach((score, players) ->
        players.forEach(player ->
            System.out.println(player + ": " + score)));
}

Java

import java.util.*;
import java.util.concurrent.*;

public class Leaderboard {
    // Map scores to players, with scores in reverse order (highest first)
    private final ConcurrentSkipListMap<Double, Set<String>> scoreMap =
        new ConcurrentSkipListMap<>(Collections.reverseOrder());
    // Map players to their current scores
    private final ConcurrentHashMap<String, Double> playerScores = new ConcurrentHashMap<>();

    // Add or update a player's score
    public void addScore(String player, double score) {
        Double oldScore = playerScores.put(player, score);
        if (oldScore != null) {
            // Remove player from old score set
            scoreMap.computeIfPresent(oldScore, (k, v) -> {
                v.remove(player);
                return v.isEmpty() ? null : v;
            });
        }
        // Add player to new score set
        scoreMap.compute(score, (k, v) -> {
            if (v == null) v = ConcurrentHashMap.newKeySet();
            v.add(player);
            return v;
        });
    }

    // Get the top n players
    public List<String> getTopNPlayers(int n) {
        List<String> topPlayers = new ArrayList<>();
        for (Map.Entry<Double, Set<String>> entry : scoreMap.entrySet()) {
            for (String player : entry.getValue()) {
                topPlayers.add(player);
                if (topPlayers.size() == n) return topPlayers;
            }
        }
        return topPlayers;
    }

    // Display the entire leaderboard
    public void displayLeaderboard() {
        scoreMap.forEach((score, players) ->
            players.forEach(player ->
                System.out.println(player + ": " + score)));
    }
}

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Leaderboard leaderboard = new Leaderboard();

        // Thread 1 - Adding scores for group 1 of players
        Thread t1 = new Thread(() -> {
            leaderboard.addScore("Alice", 1500);
            leaderboard.addScore("Bob", 1200);
        });

        // Thread 2 - Adding scores for group 2 of players
        Thread t2 = new Thread(() -> {
            leaderboard.addScore("Charlie", 1800);
            leaderboard.addScore("Diana", 1600);
        });

        // Thread 3 - Updating existing scores
        Thread t3 = new Thread(() -> {
            leaderboard.addScore("Alice", 1900);
            leaderboard.addScore("Eve", 1700);
        });

        // Start the threads
        t1.start();
        t2.start();
        t3.start();

        // Wait for all threads to finish
        t1.join();
        t2.join();
        t3.join();

        // Display the final leaderboard
        System.out.println("=== Final Leaderboard ===");
        leaderboard.displayLeaderboard();

        // Display the top 3 players
        System.out.println("\n=== Top 3 Players ===");
        leaderboard.getTopNPlayers(3).forEach(player -> System.out.println(player));
    }
}

Designing a Thread-Safe Game Leaderboard Using ConcurrentSkipListMap

What You'll Learn

Recap: Understanding ConcurrentSkipListMap

Adjusting the Sorting Order with reverseOrder()

Join the 1M+ learners on CodeSignal

Creating the Game Leaderboard

Adding and Updating Scores

Composing atomic updates across structures:

Getting the Top Players

Displaying the Leaderboard

Final Implementation

Simulating Concurrent Updates

Why It Matters