Question

I have a class which contains a static collection that can be used across all threads. It acts as a cache. When it is first loaded from the database, it is supposed to never change. However, in rare cases, we have to clear this cache. The current way to do this is to restart the server. I want to implement a clear cache method. What is the best way to do this?

Example class:

public class DepartmentRepository {
    private static Collection<Department> departments = new ArrayList<Department>();

    public synchronized Collection<Department> getAllDepartments() {
        if (departments.isEmpty()) {
            //do database lookup
        }
        return departments;
    }
    //more methods excluded
}

I want to add a method that looks like this:

public void clearCache() {
    departments.clear();
}

But I need to make sure it clears it across all threads and doesn’t break anything.

Answer 1

In response to a follow-up comment by the OP:

Is there performance hit with using a synchronizedList? This is at the core of a massively overgrown architecture.

Yes, there is a performance hit. You’d have to measure it to find out how much. For one thing, synchronizing every operation to the Department collection might result in a lot of contention even when most of the operations are read-only. For thread safety with performance, consider something like this:

import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class DepartmentRepository
{

  private static final ReentrantReadWriteLock lock =
    new ReentrantReadWriteLock(true);

  private static Collection<Department> departments = null;

  public Collection<Department> getAllDepartments()
  {
    Lock read = lock.readLock();
    read.lock();
    try {
      /* Check whether the departments are loaded. */
      if (departments == null) {
        /* If not loaded, release read-lock and acquire write-lock. */
        read.unlock();
        Lock write = lock.writeLock();
        write.lock();
        try {
          /* Recheck condition for updates by another thread. */
          if (departments == null) {
            Collection<Department> tmp = ...; // Initialize. 
            departments = Collections.unmodifiableCollection(tmp);
          }
          /* Downgrade from write-lock to read-lock. */
          read.lock();
        }
        finally {
          write.unlock();
        }
      }
      return departments;
    }
    finally {
      read.unlock();
    }
  }

  public void clearCache()
  {
    Lock write = lock.writeLock();
    write.lock();
    try {
      departments = null;
    }
    finally {
      write.unlock();
    }
  }

}

Yes, it’s messy. Sharing data between threads is hard.