一个缓存的实现（多线程的应用）_java atomic 可以做多线程缓存吗-优快云博客

本文链接：https://blog.youkuaiyun.com/kai_wei_zhang/article/details/8260474

本文探讨了在Servlet中缓存最近计算结果时可能遇到的并发问题，强调了缺乏原子性保障的危害，指出这可能导致不变性被破坏。同时，文章提出了使用volatile类型发布不可变对象作为解决方案，以此确保缓存最新结果的安全性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

因数分解，将最近的计算结果缓存起来

1、该Servlet在没有足够原子性保证的情况下对其最近计算结果进行缓存（不要这样做）

import java.math.BigInteger;
import java.util.concurrent.atomic.*;
import javax.servlet.*;

import net.jcip.annotations.*;
@NotThreadSafe
public class UnsafeCachingFactorizer extends GenericServlet implements Servlet {
    private final AtomicReference<BigInteger> lastNumber
            = new AtomicReference<BigInteger>();
    private final AtomicReference<BigInteger[]> lastFactors
            = new AtomicReference<BigInteger[]>();

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        if (i.equals(lastNumber.get()))
            encodeIntoResponse(resp, lastFactors.get());
        else {
            BigInteger[] factors = factor(i);
            lastNumber.set(i);
            lastFactors.set(factors);
            encodeIntoResponse(resp, factors);
        }
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[]{i};
    }
}

上面会出现并发问题，虽然该类包含两个能进行原子操作的状态，但是两次状态修改操作之间，其他线程将发现不变性被破坏了

2、下面使用volatile类型来发布不可变对象

import java.math.BigInteger;
import java.util.*;

import net.jcip.annotations.*;
@Immutable
public class OneValueCache {
    private final BigInteger lastNumber;
    private final BigInteger[] lastFactors;

    public OneValueCache(BigInteger i,
                         BigInteger[] factors) {
        lastNumber = i;
        lastFactors = Arrays.copyOf(factors, factors.length);
    }

    public BigInteger[] getFactors(BigInteger i) {
        if (lastNumber == null || !lastNumber.equals(i))
            return null;
        else
            return Arrays.copyOf(lastFactors, lastFactors.length);
    }
}

使用指向不可变容器对象的volatile类型引用以缓存最新的结果

import java.math.BigInteger;
import javax.servlet.*;

import net.jcip.annotations.*;
@ThreadSafe
public class VolatileCachedFactorizer extends GenericServlet implements Servlet {
    private volatile OneValueCache cache = new OneValueCache(null, null);

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = cache.getFactors(i);
        if (factors == null) {
            factors = factor(i);
            cache = new OneValueCache(i, factors);
        }
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[]{i};
    }
}