multithreading - 为每个对象加载生成一个新线程

Question

我有一个运行多个服务(长期)和工作(短期)线程的系统。它们都共享一个包含对象的状态。任何线程都可以通过一个名为 ObjectManager 的单例类随时请求一个对象。 .如果对象不可用，则需要加载它。

以下是对象加载现在的一些伪代码:

class ObjectManager {
    getLoadinData(path) {
        if (hasLoadingDataFor(path))
            return whatWeHave()
        else {
            loadingData = createNewLoadingData();
            loadingData.path = path;
            pushLoadingTaskToLoadingThread(loadingData);
            return loadingData;
        }
    }

    // loads object and blocks until it's loaded
    loadObjectSync(path) {
        loadingData = getLoadinData(path);
        waitFor(loadingData.conditionVar);
        return loadingData.loadedObject;
    }

    // initiates a load and calls a callback when done
    loadObjectAsync(path, callback) {
        loadingData = getLoadinData(path);
        loadingData.callbacks.add(callback);
    }

    // dedicated loading thread
    loadingThread() {
        while (running) {
            loadingData = waitForLoadingData();        
            object = readObjectFromDisk(loadingData.path);

            object.onLoaded(); // !!!!

            loadingData.object = object;
            // unblock cv waiters
            loadingData.conditionVar.notifyAll();
            // call callbacks
            loadingData.callbacks.callAll(object);
        }
    }    
}

问题是 object.onLoaded 行.我无法控制此功能。一些对象可能决定它们需要其他对象才能有效。所以在他们的 onLoaded他们可能调用的方法 loadObjectSync .哦哦!这(自然)死锁。它阻塞加载循环，直到加载循环进行更多迭代。

我能做的就是离开 onLoaded调用启动线程。这将改变 loadObjectSync类似于:

loadObjectSync(path) {
    loadingData = getLoadinData(path);
    waitFor(loadingData.conditionVar);
    if (loadingData.wasCreatedInThisThread()) {
        object.onLoaded();
        loadingData.onLoadedConditionVar.notifyAll();
        loadingData.callbacks.callAll(object);
    }
    else {
        // wait more
        waitFor(loadingData.onLoadedConditionVar);
    }                
    return loadingData.loadedObject;
}

...但问题是，如果我没有调用 loadSync且仅适用于 loadAsync或者只是 loadAsync call 是第一个创建加载数据的，不会有任何人来完成对象。因此，为了完成这项工作，我必须引入另一个线程来完成对象，这些对象的 loadingData 是由 loadObjectAsync 创建的。

似乎它会起作用。但我有一个更简单的想法!如果我改变 getLoadingData反而。如果它这样做怎么办:

getLoadinData(path) {
    if (hasLoadingDataFor(path))
        return whatWeHave()
    else {
        loadingData = createNewLoadingData();
        loadingData.path = path;
        ///
        thread = spawnLoadingThread(loadingData);
        thread.detach();
        ///
        return loadingData;
    }
}    

为 生成一个新线程每物体载荷。因此没有死锁。每个加载线程都可以安全地阻塞，直到完成。其余代码保持原样。

这意味着可能有数十个(或者在某些边缘情况下为什么不是数千个)事件线程，等待条件变量。我知道生成线程有它的开销，但我认为与 readObjectFromDisk 的 I/O 成本相比，它可以忽略不计。

所以我的问题是:这很可怕吗？这会以某种方式适得其反吗？

目标平台是传统的台式机。但是这个软件应该可以不间断地运行很长时间:几周，甚至几个月。

或者......即使我知道如何解决这个问题，如果每个负载的线程结果很糟糕，这可以用另一种方式解决吗？

Answer 1

很有意思!这是我遇到过几次的问题，试图将同步接口(interface)添加到由服务线程执行的基本异步操作(即文件加载，或者在我的情况下是网络写入)。

我自己的偏好是不提供同步接口(interface)。为什么？因为它使代码在设计和实现中更简单，更容易推理——对于多线程来说总是很重要。

坚持单线程和仅异步的好处是您只有 1 个服务线程，因此资源增长不是问题，而且用户回调始终在同一线程上调用，这简化了 ObjectManager 用户的线程安全问题(如果您有多个回调线程，则每个用户回调都必须是线程安全的，因此这是一个重要的选择)。然而，只坚持一个异步接口(interface)确实意味着 ObjectManager 的用户还有更多的工作要做。

但是，如果您确实想保留同步接口(interface)，那么我采取的另一种方法可能对您有用。您坚持使用单个服务线程，但在 loadObjectSync 的实现中您检查线程 ID 以确定调用者是服务线程还是任何其他线程。如果它是任何其他线程，您将请求排队并安全地阻止。但是如果是服务线程，你可以立即加载对象，比如调用一个新函数loadObjectImpl .您需要在初始化期间获取服务线程的线程 ID 并将其存储在 ObjectManager 中。实例，并将其用于线程识别。您将需要一个新函数，它基本上只是 loadingThread 的内部范围。函数 -- 即一个名为 loadObjectImpl 的新函数.