Re: [boost] futures, deadlocking and mutual recursion.

2 Dec 2007

      Achilleas Margaritis:
...
Isn't there a deadlock issue with futures? suppose I have the following
code:
class A {
    int data;
public:
    int getData() const {
        return data;
    }
void someAction(B *b) {
        future<int> i = bind(b, &B::someAction, this);
        data = i.wait() + 1;
    }
};
class B {
    int data;
public:
    int someAction(A *a) {
        future<int> j = bind(a, &A::getData);
        return j.wait() + 1;
    }
};
int main() {
     A *a = new A;
     B *b = new B;
     a->someAction(b);
}
The above contains a deadlock:
It doesn't, unless the future<int> contains a magic per-object mutex. It 
would be a deadlock if A is changed as follows:

class A {
    int data;
    mutable mutex mx;

public:
    int getData() const {
        scoped_lock lock( mx );
        return data;
    }

    void someAction(B *b) {
        scoped_lock lock( mx );
        future<int> i = bind(b, &B::someAction, this);
        data = i.wait() + 1;
    }
};

which is broken. A mutex lock should never encompass a blocking call.

class A {
    int data;
    mutable mutex mx;

public:
    int getData() const {
        scoped_lock lock( mx );
        return data;
    }

    void setData( int v )
    {
        scoped_lock lock( mx );
        data = v;
    }

    void someAction(B *b) {
        future<int> i = bind(b, &B::someAction, this);
        setData( i.wait() + 1 );
    }
};

Re: [boost] futures, deadlocking and mutual recursion.

Peter Dimov