二十三种设计模式全面解析-从线程安全到创新应用：探索享元模式的进阶之路

import java.util.HashMap;
import java.util.Map;
// 抽象享元类
interface Flyweight {
    void operation();
}
// 具体享元类
class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;
    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }
    public void operation() {
        System.out.println("Concrete Flyweight: " + intrinsicState);
    }
}
// 享元工厂类
class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();
    public synchronized Flyweight getFlyweight(String key) {
        if (flyweights.containsKey(key)) {
            return flyweights.get(key);
        } else {
            Flyweight flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
            return flyweight;
        }
    }
}
public class Main {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        // 多个线程同时获取享元对象
        Runnable task = () -> {
            Flyweight flyweight = factory.getFlyweight("shared");
            flyweight.operation();
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();
    }
}

public interface Flyweight {
    void operation();
}
public class ConcreteFlyweight implements Flyweight {
    // 具体享元对象的实现
}
public class CompositeFlyweight implements Flyweight {
    private List<Flyweight> flyweights = new ArrayList<>();
    public void addFlyweight(Flyweight flyweight) {
        flyweights.add(flyweight);
    }
    @Override
    public void operation() {
        for (Flyweight flyweight : flyweights) {
            flyweight.operation();
        }
    }
}

public class DataCache {
    private Map<String, Data> cache = new HashMap<>();
    public Data getData(String key) {
        if (cache.containsKey(key)) {
            return cache.get(key);
        } else {
            Data data = fetchDataFromSource(key);
cache.put(key, data);
                return data;
            }
        }
        private Data fetchDataFromSource(String key) {
            // 从数据源获取数据的逻辑
        }
    }

public class ObjectPool<T> {
    private List<T> pool = new ArrayList<>();
    private int maxSize;
    public ObjectPool(int maxSize) {
        this.maxSize = maxSize;
    }
    public synchronized T acquireObject() {
        if (pool.isEmpty()) {
            return createObject();
        } else {
            return pool.remove(pool.size() - 1);
        }
    }
    public synchronized void releaseObject(T object) {
        if (pool.size() < maxSize) {
            pool.add(object);
        }
    }
    private T createObject() {
        // 创建对象的逻辑
    }
}