Java cache data loss: Why can't data be retrieved from cache?

Java cached data loss problem: Diagnosis and solutions

In Java applications, memory caching is a key strategy for improving performance. However, cached data loss is a common problem. This article will conduct a case analysis to explore the root causes of Java cached data in depth and provide effective optimization solutions.

Case background:

A project uses a class called scenarioBuffer to cache about 160,000 asset data into a HashMap. scenarioBuffer class uses the @Component annotation and provides a static method getBAsset for data acquisition. When the application starts, scenarioBuffer initializes the cache through ApplicationRunner interface. However, during the run, the getBAsset method frequently returns null values. What is even more confusing is that the server memory is in urgent need (only 100MB of available memory is left, the cache takes up 3GB, and the total memory is 8GB). After restarting the server and clearing the cache, the problem is temporarily solved.

Analysis of the root cause of the problem:

Despite allocating about 3GB of memory for Tomcat, insufficient server memory remains the main problem. When memory is insufficient, the JVM will trigger garbage collection and even force shutdown to release memory, causing cached data to be cleared.

Code flaws:

The original code has the following problems:

1. Static methods and singletons: scenarioBuffer class uses the static method getBAsset and the static variable assetBuffer , as well as getInstance() method. In Spring-managed Beans, this is completely unnecessary. Spring containers themselves manage singletons of beans, static methods and variables increase code complexity and are difficult to unit test.
2. Dependency injection is missing: Getting scenarioBuffer instance does not use Spring's dependency injection, but uses getInstance() method, which reduces the maintainability and testability of the code.
3. Initialization method: Although it is feasible to initialize the cache using ApplicationRunner , the @PostConstruct annotation or InitializingBean interface is clearer and easier to understand.

Optimization solution:

It is recommended to use Spring's dependency injection and @PostConstruct annotation optimization code:

Modified scenarioBuffer class:

 @Component
public class scenarioBuffer implements IActionListener {

    @Autowired
    private IAssetService assetService;

    private map <string list> > assetBuffer = new HashMap();

    @PostConstruct
    public void init() {
        List<asset> assetList = assetService.list();
        assetBuffer.put("key", assetList); // Here you need to modify the key according to the actual situation
    }

    public List<asset> getBAsset(String groupId) {
        return assetBuffer.get(groupId);
    }
}</asset></asset></string>

In the class that needs to use cache, inject scenarioBuffer instance through @Autowired :

 @Service
public class XxxService {
    @Autowired
    private ScenarioBuffer scenarioBuffer;

    public void xxx() {
        List<asset> asset = scenarioBuffer.getBAsset("xxx"); // Here you need to modify the groupId according to the actual situation
        // ...
    }
}</asset>

These modifications make the code more concise, easy to maintain and test, and avoid problems caused by static methods and variables.

In addition, you need to pay attention to the server memory usage. If memory is often insufficient, consider increasing server memory or optimizing programs to reduce memory usage. Although Redis is not considered for the time being in the case, in the long run, using distributed caches such as Redis can effectively alleviate memory pressure and improve performance.

The above is the detailed content of Java cache data loss: Why can't data be retrieved from cache?. For more information, please follow other related articles on the PHP Chinese website!