Guava Cache Deadlock

[xuzhenmin]

Version： 19 - 28
Cache strategy：refreshAfterWrite
method：compute & get -> refresh

Scenes：
Thread1 compute
Thread2 refresh

When compute, there will be a deadlock with refresh

CacheBuilder.newBuilder() .maximumSize(cacheSize) .refreshAfterWrite(duration, timeUnit) .build(cacheLoader)

Source code：
compute

refresh

[nick-someone]

Hi there. I'm not sure I'm following this here.

Is it possible to demonstrate this with a test case that you expect to fail occasionally depending on thread scheduling?

[gabikliot]

Was that deadlock verified and/or fixed?

[yearhasfish]

is this a real bug to be fixed by Guava?

[xuzhenmin]

Hi there. I'm not sure I'm following this here.

Is it possible to demonstrate this with a test case that you expect to fail occasionally depending on thread scheduling?

test case:

/**
 * @author zhenmin
 * @version $Id: GuavaCacheLockTest.java, v 0.1 2020-04-09 9:16 PM zhenmin Exp $$
 */
public class GuavaCacheLockTest {

    /**
     * executor
     */
    private ListeningExecutorService executor;
  
    LoadingCache<String, Optional<String>> localCache;
    /**
     *
     */
    private final Executor threadPool = Executors.newFixedThreadPool(3);
    
    @Before
    public void initCache() {
        executor = MoreExecutors.listeningDecorator(new ThreadPoolExecutor(2,
            2, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(1000),
            new TestThreadFactory(this.getClass().getName() + "_DefaultCoordinator"),
            new ThreadPoolExecutor.AbortPolicy()));
        // 
        localCache = CacheBuilder.newBuilder().maximumSize(15).refreshAfterWrite(1, MILLISECONDS).recordStats()
            .build(new CacheLoader<String, Optional<String>>() {
                @Override
                public Optional<String> load(final String key) throws Exception {
                    return loadData(key);
                }
                @Override
                public ListenableFuture<Optional<String>> reload(final String key,
                                                                 Optional<String>
                                                                     oldData)
                    throws Exception {
                    ListenableFutureTask<Optional<String>> task = ListenableFutureTask.create(
                        () -> reloadData(key, oldData));
                    executor.execute(task);
                    return task;
                }
            });
    }
    /**
     * @throws Exception
     */
    @Test
    public void testGetAndPut() throws Exception {
        threadPool.execute(new WorkerR());
        threadPool.execute(new WorkerW("1"));
        threadPool.execute(new WorkerW("2"));
        //10
        TimeUnit.SECONDS.sleep(10);
    }
   
    class WorkerW implements Runnable {
        private String k;
        WorkerW(String k) {
            this.k = k;
        }
        @Override
        public void run() {
            while (true) {
                localCache.asMap().compute(k, (key, oldV) -> Optional.of(("" + System.currentTimeMillis())));
                try {
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (Exception e) {}
            }
        }
    }
    
    class WorkerR implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    //
                    String[] ks = new String[] {
                        (new Random().nextInt(10) + ""), (new Random().nextInt(10) + ""), (new Random().nextInt(10) + "")
                    };
                    System.out.println(localCache.getAll(Lists.newArrayList(ks)));
                }
            } catch (Exception e) {}
        }
    }
    private Optional<String> loadData(String key) {
        return Optional.of("1");
    }
    private Optional<String> reloadData(String key, Optional<String> oldData) {
        try {
            //
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (Exception e) {}
        return oldData;
    }
    /**
     * 
     * @throws Exception
     */
    @Test
    public void testCacheGet() throws Exception {
        String key = "1";
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println(localCache.get(key));
                TimeUnit.MILLISECONDS.sleep(15);
            } catch (Exception e) {
                //
                e.printStackTrace();
            }
        }
    }
}
class TestThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final String namePrefix;
    private final boolean isDaemon;
    public TestThreadFactory(String name) {
        this(name, false);
    }
    public TestThreadFactory(String prefix, boolean daemon) {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        namePrefix = prefix + "-" + poolNumber.getAndIncrement() + "-test-thread-";
        isDaemon = daemon;
    }
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        t.setDaemon(isDaemon);
        if (t.getPriority() != Thread.NORM_PRIORITY) {
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }
}