如何设计一个可以使用类属性/方法存储和检索数据的类

class DataStore:
    # 类属性，用于存储共享数据
    shared_data = {}

    def __init__(self, instance_id):
        # 实例属性，用于存储每个实例的特定数据
        self.instance_id = instance_id
        self.instance_data = {}

    def store_data(self, key, value):
        """存储数据到实例属性和类属性"""
        self.instance_data[key] = value
        DataStore.shared_data[self.instance_id] = self.instance_data

    def retrieve_data(self, key):
        """从实例属性和类属性检索数据"""
        if key in self.instance_data:
            return self.instance_data[key]
        elif self.instance_id in DataStore.shared_data and key in DataStore.shared_data[self.instance_id]:
            return DataStore.shared_data[self.instance_id][key]
        else:
            return None

    @classmethod
    def retrieve_shared_data(cls, instance_id):
        """从类属性检索共享数据"""
        return cls.shared_data.get(instance_id, {})

# 示例使用
if __name__ == "__main__":
    # 创建两个实例
    ds1 = DataStore(instance_id="instance1")
    ds2 = DataStore(instance_id="instance2")

    # 存储数据
    ds1.store_data("name", "Alice")
    ds2.store_data("name", "Bob")

    # 检索数据
    print(ds1.retrieve_data("name"))  # 输出: Alice
    print(ds2.retrieve_data("name"))  # 输出: Bob

    # 检索共享数据
    print(DataStore.retrieve_shared_data("instance1"))  # 输出: {'name': 'Alice'}
    print(DataStore.retrieve_shared_data("instance2"))  # 输出: {'name': 'Bob'}

import threading

class DataStore:
    shared_data = {}
    lock = threading.Lock()

    def store_data(self, key, value):
        with DataStore.lock:
            self.instance_data[key] = value
            DataStore.shared_data[self.instance_id] = self.instance_data

    @classmethod
    def retrieve_shared_data(cls, instance_id):
        with cls.lock:
            return cls.shared_data.get(instance_id, {})