如何使用 java 处理缓存中的锁定 (ConcurrentHashMap)

Question

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

提前致谢。

Answer 1

ConcurrentHashMap#computeIfAbsent

正如Wasserman 所评论的那样， ConcurrentHashMap class 提供了一个computeIfAbsent方法来做你想做的事。 该方法以原子方式工作以：

• 查看 map 是否有该键的条目。 如果是，则返回该键的值。
• 如果未找到条目，则执行您指定的 lambda function 以产生一个值。 该值作为键值条目存储在 map 中。 并且，该值被返回。

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

引用 Javadoc：

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

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

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

…或使用方法调用：

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

示例应用

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

我们使用 map 跟踪哪个星期几分配给哪个人的姓名，将String映射到java.time.DayOfWeek枚举 ZA8CFDE6331BD59EB2AC96F8911C4OfWeek Map< String, DayOfWeek >

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

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

我们要执行的任务被定义为一个返回DayOfWeek object 的Callable 。 我们将Callable object 多次提交给执行器服务。 该服务返回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 , 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;
        }
    }
}

请参阅在 IdeOne.com 上实时运行的代码。

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

Answer 2

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

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();
  }
}