假设我有一个类 A
:
class A {
public:
A();
void fetch_data() { return 1; }
void write_x_data() {
// lock this instance of A
private_function1_which_assumes_locked();
private_function2_which_assumes_locked();
// unlock this instance of A
}
void write_y_data() {
// lock this instance of A
private_function1_which_assumes_locked();
// unlock this instance of A
}
private:
void private_function1_which_assumes_locked();
void private_function2_which_assumes_locked();
};
我想保证 private_function*_which_assumed_locked()
永远不会被调用,除非 A
被锁定。
实现此目标的最佳方法是什么?我有 5 个左右的公共(public)函数需要锁定。这些函数从不互相调用,所以我不担心与它们发生死锁。结合起来,这 5 个公共(public)函数调用大约 15 个不同的私有(private)函数,这些函数需要假定对象处于锁定状态。显然,我不能锁定私有(private)函数,因为我会遇到死锁。
假设存在互斥锁和Scopeguards,请随意提供合理的高级抽象的答案。 .
在 Python 中,我可能会用 decorators 做一些类似的事情:
class locked_method(object):
def __init__(self, f):
self.f = f
def __call__(self):
# Do whatever is needed to lock
self.f()
# Do whatever is needed to unlock
class checklocked(object):
def __init__(self, f):
self.f = f
def __call__(self):
# check locked, if not, don't call self.f(),
# and yell at me loudly for screwing up.
self.f()
@locked_method
def func1():
__function_which_assumes_locked()
@checklocked
def __function_which_assumes_locked():
pass
注意:我在 Python 方面做得不多,所以如果我的 Python 错误/愚蠢,请随时发表评论,但这个问题的重点更多是在 C++ 中完成此类事情的最佳方式,所以希望提供的 Python 足以让您了解我想做什么。
最佳答案
您可以使用储物柜类,并要求存在一个储物柜类才能调用私有(private)函数:
class A
{
public:
void write()
{
Lock l(this);
write(l);
}
private:
void lock();
void unlock();
void write(const Lock &);
class Lock
{
public:
explicit Lock(A *a) : parent(a) {parent->lock();}
~Lock() {parent->unlock();}
private:
A *parent;
};
};
关于c++ - 确保某些私有(private)函数只能从锁定状态调用,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/1771518/