我有缓存列表，我的代码是这样的

public class MyList {
private final List<String> cache = new ArrayList<String>();

private List<String> loadMyList() {
    // HEAVY OPERATION TO LOAD DATA
}

public List<String> list() {
    synchronized (cache) {
        if( cache.size() == 0 ) {
            cache.addAll(loadMyList());
        }
        return Collections.unmodifiableList(cache);
    }
}

public void invalidateCache() {
    synchronized (cache) {
        cache.clear();
    }
}
}

因为列表加载非常重，我收到一个请求，如果列表加载当前正在进行中，我将返回“旧”缓存数据...

这可能吗，有人可以指导我如何从这里开始吗

编辑:Adam Horvath 和 bayou.io 提出了这样的建议

public class MyList 
{
private final List<String> cache = new ArrayList<String>();
private final List<String> oldCache = new ArrayList<String>();
private volatile boolean loadInProgress = false;

private List<String> loadMyList()
{
    // HEAVY OPERATION TO LOAD DATA
}

public List<String> list()
{
    synchronized (cache)
    {
        if( loadInProgress )
            return Collections.unmodifiableList( oldCache );
        else
            return Collections.unmodifiableList(cache);
    }
}

public void invalidateCache()
{
    synchronized (cache)
    {
        // copy to old cache
        oldCache = new ArrayList<String>( cache );
        // set flag that load is in progress
        loadInProgress = true;
        // clear cache
        cache.clear();

        // initialize load in new thread
        Thread t = new Thread(new Runnable()
        {
            public void run()
            {
                cache.addAll( loadMyList() );
                // set flag that load is finished
                loadInProgress = false;
            }
       });  
       t.start();


    }

   }
}

修改后的代码会有问题吗？？ 由于我在多线程和/或兑现优化方面没有经验，我将不胜感激任何和所有性能建议

最佳答案

“因为列表负载非常重，所以我收到一个请求，如果列表加载当前正在进行中，我将返回“旧的”缓存数据...”

由于您的“同步(缓存)” block ，这不会发生。您需要一个 volatile boolean 标志(互斥锁)来告诉您正在生成一个列表。当线程尝试获取 list() 并且互斥量为真时，它将接收缓存的。当 loadMyList() 完成时将其设置为 false。

因此，删除同步块(synchronized block)并开始在单独的线程中加载您的列表。

public class MyList {
    private List<String> cache = new ArrayList<String>();
    private volatile boolean loadInProgress = false;

    private List<String> loadMyList() {
        // HEAVY OPERATION TO LOAD DATA
    }

    public List<String> list() {
        // Whatever is in cache, you can always return it
        return Collections.unmodifiableList(cache);
    }

    /**
     * Starts the loader-thread and then continues.
     */
    public void invalidateCache() {
        // Next two lines make sure only one Loader-thread can be started at the same time
        synchronized (cache) {
            if (!loadInProgress) {
                // initialize load in new thread
                Thread t = new Thread("Loader-thread") {
                    @Override
                    public void run() {
                        List<String> toAssign = loadMyList();
                        // You can simply assign instead of copying
                        cache = toAssign;
                        // cache now "points to" refreshed list
                        loadInProgress = false;
                    }
                };
                loadInProgress = true;
                t.start();
                // Now let's exit the synchronized block. Hopefully the Thread will start working soon
            } else {
                // A Thread is already working or about to start working, don't bother him
            }
        }
    }
}

关于Java缓存对象返回旧值，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31319328/