使用线程安全方法从类中的多个方法填充 Collection 或 Map

Question

请告知解决以下问题的最佳方法：

我有一个java类如下：

@Service
public class ServiceAImpl {

    private final Set<String> someSet = new HashSet<>();
    private final List<Record> someList = new ArrayList<>();
    private final Map<String, String> someMap = new HashMap<>();

   //Loads XML as a document
   public Optional<Document> readXML(Document xmlDoc){

   }

   //reads the root node and triggers the recursive extraction of the XML data
   public List<Record> extractRootNodeAndTriggersRecursive(){
       extractXMLRecursively(elt);

   }

   //recursively read hierarchical data in the XML
   public SomeObject extractXMLRecursively(Element elt){

   }

   public SomeObject createReportFromTheMapOrList(){

   }

}

我知道实例成员（或列表/映射）不是线程安全的。

请问在需要通过多次调用同一类中定义的多个方法来更新或填充列表/集合/映射的逻辑时，最好的方法是什么。

因此，在另一个调用类（主 Springboot 应用程序）中，我将获取列表/设置/映射以在填充后处理它们。

我认为上述代码可能适用于按计划每周运行一次的独立应用程序，即并发性不会成为问题。但是，如果服务暴露给多个线程，我应该如何修改它？

有人遇到过这种情况吗？

任何想法或提示或参考将不胜感激。

谢谢。

Answer 1

你可以使用ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

@Service
public class ServiceAImpl {

    private final Set<String> setNoDuplicateLabelsAllowed = new HashSet<>();
    private final Set<String> someSet = new HashSet<>();

    private final ReentrantLock lock = new ReentrantLock();

   //Loads XML as a document
   public Optional<Document> readXML(Document xmlDoc){
       lock.lock();
       try {
           // modify your collections safely here
       } finally {
           lock.unlock();
       }
   }

   //reads the root node and triggers the recursive extraction of the XML data
   public List<Record> extractRootNodeAndTriggersRecursive(){
       lock.lock();
       try {
           // modify your collections safely here
       } finally {
           lock.unlock();
       }
   }

   //recursively read hierarchical data in the XML
   public SomeObject extractXMLRecursively(Element elt){
       lock.lock();
       try {
           // same here, etc.
       } finally {
           lock.unlock();
       }
   }

请注意，您需要在每种方法中使用相同的锁。这保证了只有一个线程可以在特定时刻更改您的集合。除非释放锁，否则所有其他线程都将被阻塞，无论它们尝试以何种特定方法获取此锁。