Singleton Instance variables concurrency

Question

Below I have code from a class that is used for caching data from a database. The class is implemented as a singleton.
My question deals with the method getCacheObj(). Does getCacheObj() return a copy of the reference to cacheObj or does it return the actual cacheObj variable itself?
Specifically I am concerned about a concurrency issue when the methods refreshCache() and getCacheObj() are called simultaneously. What would happen in the following situation:
Thread 1 calls findActiveByWebsiteArea() which calls getCacheObj(). getCacheObj() returns the cacheObj for processing down the line in a jsp or other java object. Prior to thread 1 finishing the processing with cacheObj, thread 2 calls refreshCache() which resets cacheObj. Is it possible for thread 2 to clash with thread 1?
public class NewsPeer extends AncestorCachePeer {
// object that will house the cached data
protected static NewsPeer cacheObj = null;
// attributes for the instantiated cache object
private Hashtable newsByWebsiteArea = null;
private NewsPeer() {
// private constructor to enforce a singleton
public static void refreshCache() throws Exception {
// reset the cache object so a fresh retrieve will be performed
// the next time the cache is accessed
synchronized (cacheObj) {
cacheObj = null;
private static NewsPeer getCacheObj() throws Exception {
synchronized (cacheObj) {
if (cacheObj == null) {
cacheObj = new NewsPeer();
cacheObj.retrieveCache();
return cacheObj;
public static List findActiveByWebsiteArea(String websiteareaId) throws Exception{
// get item from cache obj
return (List) getCacheObj().newsByWebsiteArea.get(websiteareaId);
private void retrieveCache() throws Exception {
// code to populate newsByWebsiteArea on cacheObj
}

Answer 1

1) Do I really need to have a singleton to house the
cached data, or is it kosher to have the static
variable newsByWebsiteArea on the class
itself?That IS a singleton. You have exactly one instance of something. That's what a singleton is. It's true that you don't have any instances of NewsPeer, but you do have exactly one instance of the things you're interested in.
2) Will my code require synchronized methods for
findActiveByWebsiteArea() and
findActiveByLocation()? I don't want to have
issues inside these methods while the
refreshCache() method is running.Yes.
3) If I have other non-synchronized static
methods in this class, will the thread calling the
non-synchronized methods have to wait until the
synchronized methods are finished executing?No. Only synchronized methods or blocks respect the locks held by other synchronized methods or blocks.
If so, would it be a better idea to go back to synchronizing
blocks of code instead of methods to ensure maximum
efficiency?Your earlier examples synchronized on the entire method's code. I don't understand why you would think that would work differently than just synchronizing the method itself. The lock is held for exactly the same code.
Now if the critical block was only part of the method, you might want to synchronize on that. But in your case it isn't.
However: you actually have two independent objects there. So you could do something like this: public class NewsPeer extends AncestorCachePeer {
    // attributes for the instantiated cache object
    private static Hashtable newsByWebsiteArea = new Hashtable();
    private static Hashtable newsByLocation = new Hashtable();
    static {
        try {
            refreshCache();
        } catch (Exception e) {
            e.printStackTrace();
    public static List findActiveByWebsiteArea(String websiteareaId) throws Exception{
        synchronized(newsByWebsiteArea) {
        // get item from cache obj
        return (List) newsByWebsiteArea.get(websiteareaId);
    public static List findActiveByLocation(String locationId) throws Exception{
        synchronized(newsByLocation) {
        // get item from cache obj
        return (List) newsByLocation.get(locationId);
    public static void refreshCache() throws Exception {
        // retrieve items that will be cached
        synchronized(newsByWebsiteArea) {
        newsByWebsiteArea.clear();
        // additional code to populate newsByWebsiteArea
        synchronized(newsByLocation) {
        newsByLocation.clear();
         // additional code to populate newsByLocation
    }That way the two "find" methods don't block each other. (Note that I changed your code slightly so you don't create new objects in the refresh() method. That's because the revised code synchronizes on the objects in question, so creating new objects would lead to synchronization failures.
Or as stefan.schulz suggests, you could use Java 5 synchronization tools to improve this. I don't know much about them but I'm pretty sure there's something that lets readers share the data without blocking and only blocks when writers are active. That's probably worth looking into.