Question

Another possibly inane style question:

How should concurrency be locked? Should the executor or caller be responsible for locking the thread?

e.g. in no particular language…

Caller::callAnotherThread() {
    _executor.method();
}

Executor::method() {
    _lock();
    doSomething();
    _unlock();
}

OR

Caller::callAnotherThread() {
    _executor.lock()
    _executor.method();
    _executor.unlock()
}

Executor::method() {
    doSomething();
}

I know little about threading and locking, so I want to make sure the code is robust. The second method allows thread unsafe calls… you could technically call _executor.method() without performing any kind of lock.

Help?

Thanks,

Answer 1

The callee, not the caller should do the locking. The callee is the only one who knows what needs to be synchronized and the only one who can ensure that it is. If you leave locking up to the callers, you do three bad things:

1. You increase the burden on users of your function/class, increasing design viscosity.
2. You make it possible for callers to update shared state without taking the lock.
3. You introduce the possibility of deadlocks if different functions take multiple locks in different order.