Le 19/02/13 17:58, Gabriel Bizzotto a écrit :

Hi !

I've created two simples classes that helped me avoid data races when sharing objects among threads.

The idea is to declare objects that need for synchronization as Synchronized<T>, which holds a T and a mutex. To use the T, a Get function has to be called that returns a proxy, which holds a pointer to the T and a scoped lock on the mutex. The proxy defines operator-> and operator* to give access to the T. To have acces to the T, one has to create the proxy. As long as the proxy exists, the mutex associated with the T is locked, effectively preventing use by other threads.

For more details and examples, I've already published the classes here http://codereview.stackexchange.com/questions/15632/force-locking-for-thread-safety/15742#15742

I find the scheme general purpose enough to fit the Atomic lib, or perhaps Thread.

Please manifest yourselves if there is any interest in such device.

Hi,

I've been working already on a synchronized_value class that is in trunk [1]. I plan to merge it to release branch as soon as I have finished the tests and the documentation. You can see some examples in [2] and [3].

I've take a look to your class and I think my class provides everything yours provide.

My class allows in addition to lock several synchronized values using the deadlock free lock algorithm as e.g.

class Person3 {
public:
Person3(unsigned int age) :
    age_(age)
{ }
std::string GetName() const {
    Invariant();
    return name_;
}
void SetName(const std::string& newName) {
    Invariant();
    name_ = newName;
}
private:
std::string name_;
unsigned int age_;
void Invariant() const {
    if (age_ < 1) throw std::runtime_error("Age cannot be negative");
}
};

typedef boost::synchronized_value<Person3> Person3_ts;

int main() {
    Person3_ts p1(1);
    Person3_ts p2(2);
    Person3_ts p3(3);
    auto lk1 = p1.unique_synchronize(boost::defer_lock);
    auto lk2 = p2.unique_synchronize(boost::defer_lock);
    auto lk3 = p3.unique_synchronize(boost::defer_lock);
    boost::lock(lk1,lk2,lk3);

    lk1->SetName("Carmen");
    lk2->SetName("Javier");
    lk3->SetName("Matias");
}

Please could you compare your class to mine and let me know what do you think?

Best,
Vicente

[1] https://svn.boost.org/svn/boost/trunk/boost/thread/synchronized_value.hpp
[2] https://svn.boost.org/svn/boost/trunk/libs/thread/example/synchronized_value.cpp
[3] https://svn.boost.org/svn/boost/trunk/libs/thread/example/synchronized_person.cpp