轻量级包装器 - 这是一个常见问题吗？如果是，它的名字是什么？

Question

我必须使用一个库来进行非线程安全的数据库调用。另外，我有时必须在后台线程中加载大量数据。
很难说哪些库函数实际上访问了数据库，所以我认为对我来说最安全的方法是用锁保护每个库调用。

假设我有一个库对象：

dbLib::SomeObject someObject;

现在我可以做这样的事情：

dbLib::ErrorCode errorCode = 0;
std::list<dbLib::Item> items;
{
    DbLock dbLock;
    errorCode = someObject.someFunction(&items);
} // dbLock goes out of scope

我想将其简化为这样的事情（甚至更简单）：

dbLib::ErrorCode errorCode =
    protectedCall(someObject, &dbLib::SomeObject::someFunction(&items));

这样做的主要优点是我不必复制接口dbLib::SomeObject 以便用锁保护每个调用。

我很确定这是一个常见的模式/习惯用法，但我不知道它的名称或要搜索的关键字。 （查看 http://www.vincehuston.org/dp/gof_intents.html 我我想，这更像是一种习语而不是一种模式）。

我必须在哪里寻找更多信息？

Answer 1

您可以将 protectedCall 设为一个模板函数，它采用不带参数的函子（意味着您将在调用站点绑定参数），然后创建作用域锁、调用函子并返回其值。例如：

template <typename Ret>
Ret protectedCall(boost::function<Ret ()> func)
{
    DbLock lock;
    return func();
}

您可以这样调用它：

dbLib::ErrorCode errorCode = protectedCall(boost::bind(&dbLib::SomeObject::someFunction, &items));

EDIT。如果您使用的是 C++0x，则可以使用 std::function 和 < code>std::bind 而不是 boost 等价物。

Answer 2

在 C++0x 中，您可以实现某种形式的装饰器：

template <typename F>
auto protect(F&& f) -> decltype(f())
{
    DbLock lock;
    return f();
}

用法：

dbLib::ErrorCode errorCode = protect([&]() 
{
    return someObject.someFunction(&items); 
});

Answer 3

从你的描述来看，这似乎是装饰器模式的工作。

但是，特别是在资源方面，我不建议使用它。

原因是，一般来说，这些函数往往扩展性很差，需要更高级别（不太细粒度）的锁定来保持一致性，或者返回对内部结构的引用，这些内部结构需要锁保持锁定状态，直到读取所有信息。

例如，考虑一个调用返回 BLOB（流）或引用游标的存储过程的 DB 函数：不应在锁之外读取流。

该怎么办？

我建议改用外观模式。不要直接根据数据库调用来编写操作，而是实现一个使用数据库层的外观；然后，该层可以在所需的级别上管理锁定（并在需要时进行优化：您可以将外观实现为线程本地单例，并使用单独的资源，从而消除对锁的需要，例如）

Answer 4

最简单（而且仍然直接）的解决方案可能是编写一个返回对象代理的函数。代理执行锁定和重载 ->允许调用该对象。这是一个示例：

#include <cstdio>

template<class T>
 class call_proxy 
 {
  T &item; 
  public:

  call_proxy(T &t) : item(t) { puts("LOCK"); }
  T *operator -> () { return &item; }
  ~call_proxy() { puts("UNLOCK"); }
 };

template<class T>
call_proxy<T> protect(T &t) 
{    
 return call_proxy<T>(t);
}

下面是如何使用它：

class Intf
{
 public:
  void function() 
 {
  puts("foo");
 }
};

int main()
{
 Intf a; 
 protect(a)->function(); 
}

输出应该是：

LOCK
foo
UNLOCK

如果您希望锁定在参数求值之前发生，则可以使用此宏：

#define PCALL(X,APPL) (protect(X), (X).APPL)
PCALL(x,x.function());

不过，这会计算 x 两次。

Answer 5

Andrei Alexandrescu 的这篇文章有一篇非常有趣的文章如何创建这种薄包装纸和将其与可怕的 volatile 关键字结合起来以确保线程安全。

Answer 6

互斥锁是一个类似的问题。它在这里寻求帮助：需要一些反馈如何使类“线程安全”

我想出的解决方案是一个包装类，它可以防止访问受保护的对象。可以通过“accessor”类获得访问权限。访问器将在其构造函数中锁定互斥锁，并在销毁时将其解锁。请参阅 Threading.h 了解更多详细信息。