如何解决如何使用java处理缓存中的锁定ConcurrentHashMap

我正在设计一个使用 concurrenthashmap 的缓存系统，它在多个线程之间共享。它也有两种方法，get 和 put。我无法处理一种情况。场景是，如果多个线程想要从缓存中获取数据而key不可用，那么一个线程会从数据库中获取数据并将其放入缓存(ConcurrentHashMap)。其他线程将等到 thread-1 将数据设置到缓存中，然后其他线程将从缓存中读取数据。我将如何实现这一目标。

提前致谢。

解决方法

`ConcurrentHashMap#computeIfAbsent`

作为 commented by Wasserman，ConcurrentHashMap 类提供了一个 computeIfAbsent 方法来执行您想要的操作。该方法以原子方式工作：

查看地图是否有该键的条目。如果是，则返回该键的值。
如果未找到任何条目，则执行您指定的 lambda 函数以生成一个值。该值作为键值条目存储在映射中。并且，该值被返回。

所有这些工作都是以原子方式进行的，这意味着您的地图以线程安全的方式运行，而无需添加任何进一步的保护。

引用 Javadoc：

如果指定的键尚未与值关联，则尝试使用给定的映射函数计算其值并将其输入此映射，除非为空。整个方法调用以原子方式执行。

使用方法引用为您的代码从数据库中检索值的示例代码：

map.computeIfAbsent( myKey,key -> repository::fetchValueForKey ) ;

... 或使用方法调用：

map.computeIfAbsent( myKey,key -> myRepository.fetchValueForKey( key ) ) ;

示例应用

这是一个完整的示例应用。

我们使用一个映射来跟踪哪个星期几被分配给了哪个人的名字，将一个 String 映射到一个 java.time.DayOfWeek 枚举对象，一个 Map< String,DayOfWeek >。

我们从 Alice 和 Bob 的两个条目的映射开始。我们的目标是为 Carol 找到第三个条目。如果未找到，请为该键添加一个值为 DayOfWeek.THURSDAY 的条目。

我们定义了一个类 Repository，我们假装它正在调用数据库来查找分配给 Carol 键的值。

我们要执行的任务被定义为一个 Callable，它返回一个 DayOfWeek 对象。我们将 Callable 对象多次提交给执行程序服务。该服务返回 Future 对象，我们可以通过这些对象跟踪成功并检索结果（我们希望它是 DayOfWeek.THURSDAY 对象）。

为了显示结果，我们将 Map 连同每个 Future 的结果一起转储到控制台。

package work.basil.demo.threadmark;

import java.time.DayOfWeek;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

public class MapApp
{
    public static void main ( String[] args )
    {
        MapApp app = new MapApp();
        app.demo();
    }

    private void demo ( )
    {
        Map < String,DayOfWeek > inputs =
                Map.of(
                        "Alice",DayOfWeek.MONDAY,"Bob",DayOfWeek.TUESDAY
                );
        ConcurrentMap < String,DayOfWeek > map = new ConcurrentHashMap <>( inputs );
        System.out.println( "INFO - Before: map = " + map );

        Repository repository = new Repository();

        ExecutorService executorService = Executors.newCachedThreadPool();

        Callable < DayOfWeek > task = ( ) -> { return map.computeIfAbsent( "Carol",( String personNameKey ) -> {return repository.fetchDayOfWeekForPersonName( personNameKey ); } ); };
        List < Callable < DayOfWeek > > tasks = List.of( task,task,task );
        List < Future < DayOfWeek > > futures = List.of();
        try
        {
            futures = executorService.invokeAll( tasks );
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }

        executorService.shutdown();
        try { executorService.awaitTermination( 10,TimeUnit.SECONDS ); } catch ( InterruptedException e ) { e.printStackTrace(); }

        System.out.println( "INFO - After: map = " + map );
        futures.stream().forEach( dayOfWeekFuture -> {
            try
            {
                System.out.println( dayOfWeekFuture.get() );
            }
            catch ( InterruptedException e )
            {
                e.printStackTrace();
            }
            catch ( ExecutionException e )
            {
                e.printStackTrace();
            }
        } );
    }

    class Repository
    {
        public DayOfWeek fetchDayOfWeekForPersonName ( final String personName )
        {
            return DayOfWeek.THURSDAY;
        }
    }
}

看到这个code run live at IdeOne.com。

INFO - Before: map = {Bob=TUESDAY,Alice=MONDAY}
INFO - After: map = {Bob=TUESDAY,Alice=MONDAY,Carol=THURSDAY}
THURSDAY
THURSDAY
THURSDAY
THURSDAY
THURSDAY

您可以使用 ReadWriteLock 包提供的 java.util.concurrent。

ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
...
void write() {
  readWriteLock.writeLock().lock();
  try {
    // read from db and write to cache
  }
  finally {
    readWriteLock.writeLock().unlock();
  }
}

void read() {
  readWriteLock.readLock().lock();
  try {
    // read from cache or from the db
  }
  finally {
    readWriteLock.readLock().unlock();
  }
}