Java面试题：结合单例模式与Java内存模型，设计一个线程安全的单例类？使用内存屏障与Java并发工具类，实现一个高效的并发缓存系统？结合观察者模式与Java并发框架，设计一个可扩展的事件处理系统

public class Singleton {  
    private volatile static Singleton instance;  
  
    private Singleton() {}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.CountDownLatch;  
  
public class ConcurrentCache {  
    private ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();  
    private CountDownLatch latch = new CountDownLatch(1);  
  
    public void initializeCache() {  
        // 初始化缓存数据  
        // ...  
        latch.countDown();  
    }  
  
    public Object get(String key) {  
        try {  
            latch.await(); // 等待缓存初始化完成  
        } catch (InterruptedException e) {  
            Thread.currentThread().interrupt();  
            return null;  
        }  
        return cache.get(key);  
    }  
  
    public void put(String key, Object value) {  
        cache.put(key, value); // 使用ConcurrentHashMap的线程安全put操作  
    }  
}

import java.util.concurrent.*;  
import java.util.List;  
import java.util.ArrayList;  
  
// 事件接口  
interface Event {  
    // 事件相关的属性和方法  
}  
  
// 观察者接口  
interface Observer {  
    void update(Event event);  
}  
  
// 事件处理系统  
class EventSystem {  
    private final ExecutorService executor = Executors.newCachedThreadPool();  
    private final List<Observer> observers = new ArrayList<>();  
  
    public void registerObserver(Observer observer) {  
        observers.add(observer);  
    }  
  
    public void notifyObservers(final Event event) {  
        for (Observer observer : observers) {  
            executor.submit(() -> observer.update(event));  
        }  
    }  
}  
  
// 示例事件和观察者实现  
class SampleEvent implements Event {  
    // 示例事件的实现  
}  
  
class SampleObserver implements Observer {  
    @Override  
    public void update(Event event) {  
        if (event instanceof SampleEvent) {  
            // 处理SampleEvent的逻辑  
        }  
    }  
}