Java - 保存单实例集合的有效方法

Question

我有多个列表和 map (并发的)。我需要将这些集合保留为单个实例。它们将被多个线程修改，并且可以从其他对象访问。

我应该创建一个线程安全的单例类并使用 getter 方法将所有这些集合保留为私有(private)字段吗？这是一个好方法吗？还有其他替代解决方案吗？或者我应该将这些集合作为公共(public)静态实例保留在其有意义的实体 java bean 中？

选项 1:将集合保留在单例实例中。

实体:

package com.anilaltunkan;

import java.util.List;

public class Employee {
    private String name;
    private String lastname;
    private int age;
    private double salary;
    private List<String> addresses;

    //getters and setters
    //.
    //.
    //.
}

单例:

package com.anilaltunkan;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Singleton {
    private static Singleton INSTANCE = null;
    private final List<Employee> employeeList = Collections.synchronizedList(new ArrayList<Employee>());
    private final Map<String, Employee> employeeMap = new ConcurrentHashMap<String, Employee>();

    private Singleton() {}

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if(INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }

    public List<Employee> getEmployeelist() {
        return employeeList;
    }

    public Map<String, Employee> getEmployeeMap() {
        return employeeMap;
    }

}

选项 2:将集合保留在 java bean 实例中并删除单例类

package com.anilaltunkan;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Employee {
    private String name;
    private String lastname;
    private int age;
    private double salary;
    private List<String> addresses;

    private static final List<Employee> employeeList = Collections.synchronizedList(new ArrayList<Employee>());
    private static final Map<String, Employee> employeeMap = new ConcurrentHashMap<String, Employee>();
}

选项 3:将集合保留在静态实用程序类中

package com.anilaltunkan;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Utility {
    private Utility() {
        throw new AssertionError();
    }

    public static final String SOME_CONSTANT = "AA";
    public static final List<Employee> employeeList = Collections.synchronizedList(new ArrayList<Employee>());
    public static final Map<String, Employee> employeeMap = new ConcurrentHashMap<String, Employee>();
}

Answer 1

这取决于。

1. employeeList 和employeeMap 是否会在一个原子操作中一起修改？那么最好创建一个包装类(例如，Employees)并从那里处理并发性。

2. 如果employeeList和employeeMap彼此不关心，那么使用list和map的并发实现并分别注入(inject)它们。

   尽管我猜测场景 1 就是您所需要的。

PS:不要使用单例，只需在main或factory中创建一个实例，然后注入(inject)它们。如果您的框架不允许这样做，请尝试探索 DI 容器，它们将为您处理单例。