Java Collections synchronizedSet() Method

The synchronizedSet() method in Java is a utility method provided by the java.util.Collections class. It returns a synchronized (thread-safe) set backed by the specified set. This method is particularly useful when you need to ensure that a set is thread-safe in a concurrent environment.

Table of Contents

1. Introduction
2. synchronizedSet() Method Syntax
3. Examples
   • Basic Usage of synchronizedSet()
   • Using synchronizedSet() with Custom Classes
4. Real-World Use Case
5. Conclusion

Introduction

The Collections.synchronizedSet() method provides a way to wrap a given set with synchronized access, ensuring that only one thread can access the set at a time. This is crucial in concurrent applications where multiple threads might try to modify the set simultaneously, leading to race conditions or inconsistent data.

The returned set is a synchronized view of the specified set, meaning that all operations on the set are synchronized using the set’s intrinsic lock. This includes operations such as adding, removing, or iterating over the elements.

synchronizedSet() Method Syntax

The syntax for the synchronizedSet() method is as follows:

public static <T> Set<T> synchronizedSet(Set<T> s)

Parameters:

• s: The set to be wrapped in a synchronized view.

Returns:

• A synchronized (thread-safe) set backed by the specified set.

Throws:

• NullPointerException if the specified set is null.

Examples

Basic Usage of synchronizedSet()

The following example demonstrates how to use the synchronizedSet() method to create a synchronized view of a set.

Example

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SynchronizedSetExample {
    public static void main(String[] args) {
        // Create a regular HashSet
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        // Create a synchronized (thread-safe) set backed by the HashSet
        Set<String> synchronizedSet = Collections.synchronizedSet(set);

        // Display the synchronized set
        System.out.println("Synchronized Set: " + synchronizedSet);

        // Use synchronized block for iteration to ensure thread safety
        synchronized (synchronizedSet) {
            Iterator<String> iterator = synchronizedSet.iterator();
            while (iterator.hasNext()) {
                System.out.println("Element: " + iterator.next());
            }
        }

        // Adding and removing elements in a synchronized set
        synchronized (synchronizedSet) {
            synchronizedSet.add("Date");
            synchronizedSet.remove("Apple");
        }

        // Display the modified synchronized set
        System.out.println("Modified Synchronized Set: " + synchronizedSet);
    }
}

Output:

Synchronized Set: [Apple, Cherry, Banana]
Element: Apple
Element: Cherry
Element: Banana
Modified Synchronized Set: [Cherry, Date, Banana]

Using synchronizedSet() with Custom Classes

You can also use the synchronizedSet() method with sets containing instances of custom classes.

Example

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

class Student {
    String name;

    Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

public class CustomSynchronizedSetExample {
    public static void main(String[] args) {
        // Create a set of students
        Set<Student> students = new HashSet<>();
        students.add(new Student("Amit"));
        students.add(new Student("Neha"));
        students.add(new Student("Raj"));

        // Create a synchronized (thread-safe) set backed by the student set
        Set<Student> synchronizedStudents = Collections.synchronizedSet(students);

        // Display the synchronized student set
        System.out.println("Synchronized Student Set: " + synchronizedStudents);

        // Use synchronized block for iteration to ensure thread safety
        synchronized (synchronizedStudents) {
            Iterator<Student> iterator = synchronizedStudents.iterator();
            while (iterator.hasNext()) {
                System.out.println("Student: " + iterator.next());
            }
        }

        // Modifying the synchronized set
        synchronized (synchronizedStudents) {
            synchronizedStudents.add(new Student("Vikram"));
            synchronizedStudents.remove(new Student("Neha"));
        }

        // Display the modified synchronized student set
        System.out.println("Modified Synchronized Student Set: " + synchronizedStudents);
    }
}

Output:

Synchronized Student Set: [Neha, Amit, Raj]
Student: Neha
Student: Amit
Student: Raj
Modified Synchronized Student Set: [Amit, Raj, Vikram]

Explanation:

1. Synchronized View: The synchronizedSet() method returns a synchronized view of the specified set, ensuring thread-safe access.

2. Synchronized Block: When iterating over the synchronized set, a synchronized block is used to avoid concurrent modification exceptions and ensure thread safety.

3. Custom Class: The method works with custom class instances, allowing you to create synchronized sets with user-defined objects.

Real-World Use Case

Thread-Safe Access to a Shared Resource

In real-world applications, the synchronizedSet() method can be used to manage thread-safe access to shared resources, such as a set of users in a multi-threaded environment.

Example

Imagine a scenario where you need to manage a shared set of users in a concurrent application.

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

class User {
    String username;

    User(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return username;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        User user = (User) obj;
        return username.equals(user.username);
    }

    @Override
    public int hashCode() {
        return username.hashCode();
    }
}

public class UserManager {
    private final Set<User> users;

    public UserManager() {
        // Initialize the user set and wrap it in a synchronized view
        this.users = Collections.synchronizedSet(new HashSet<>());
    }

    public void addUser(User user) {
        synchronized (users) {
            users.add(user);
        }
    }

    public void removeUser(User user) {
        synchronized (users) {
            users.remove(user);
        }
    }

    public void displayUsers() {
        // Use synchronized block for iteration to ensure thread safety
        synchronized (users) {
            Iterator<User> iterator = users.iterator();
            while (iterator.hasNext()) {
                System.out.println("User: " + iterator.next());
            }
        }
    }

    public static void main(String[] args) {
        UserManager userManager = new UserManager();

        // Add users to the manager
        userManager.addUser(new User("alice"));
        userManager.addUser(new User("bob"));
        userManager.addUser(new User("charlie"));

        // Display all users
        System.out.println("User List:");
        userManager.displayUsers();

        // Remove a user
        userManager.removeUser(new User("bob"));

        // Display remaining users
        System.out.println("\nUpdated User List:");
        userManager.displayUsers();
    }
}

Output:

User List:
User: bob
User: alice
User: charlie

Updated User List:
User: alice
User: charlie

Explanation:

1. User Manager: The UserManager class manages a set of users, ensuring thread-safe access by wrapping the set in a synchronized view.

2. Concurrent Environment: The synchronizedSet() method is used to synchronize access to the shared set, preventing race conditions and ensuring data consistency.

Conclusion

The Collections.synchronizedSet() method is a powerful utility for creating synchronized (thread-safe) sets in Java. By providing a simple way to wrap sets with synchronized access, it enhances the flexibility and safety of your code in concurrent environments. This method is particularly valuable in scenarios where you need to manage shared resources or ensure thread-safe access to sets, improving the robustness and maintainability of your Java applications.