Handling multiple sessions using computeIfAbsent method in Java 8

In Java 8, you can use the computeIfAbsent method from the ConcurrentHashMap class to handle multiple sessions efficiently. This method is part of the Map interface and provides a convenient way to compute a value for a given key if the key is not already associated with a value.

Here's a simple example demonstrating the use of computeIfAbsent for managing multiple sessions:

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SessionManager {
    private Map<String, Session> sessions = new ConcurrentHashMap<>();

    public Session getSession(String sessionId) {
        return sessions.computeIfAbsent(sessionId, Session::new);

    public static void main(String[] args) {
        SessionManager sessionManager = new SessionManager();

        // Get or create a session with ID "123"
        Session session1 = sessionManager.getSession("123");
        System.out.println("Session ID: " + session1.getSessionId());

        // Get or create another session with ID "456"
        Session session2 = sessionManager.getSession("456");
        System.out.println("Session ID: " + session2.getSessionId());

        // Attempt to get the first session again, it should return the existing session
        Session session1Again = sessionManager.getSession("123");
        System.out.println("Session ID: " + session1Again.getSessionId());

        // Output:
        // Session ID: 123
        // Session ID: 456
        // Session ID: 123

class Session {
    private String sessionId;

    public Session(String sessionId) {
        this.sessionId = sessionId;

    public String getSessionId() {
        return sessionId;

In this example:

  • SessionManager has a ConcurrentHashMap to store sessions.

  • The getSession method uses computeIfAbsent to retrieve an existing session for a given session ID or create a new one if it doesn't exist.

  • The Session class represents a simple session with a session ID.

Using computeIfAbsent in a concurrent environment, like the one provided by ConcurrentHashMap, ensures thread safety during session retrieval and creation. This is particularly useful when dealing with multiple sessions in a multithreaded application.