Atomic locking of multiple sync::mutex::Mutex

[toroidal-code]

There's currently no way of locking on two or more sync::mutex::Mutex at once.

C++11 provides a std::lock vs std::mutex::lock, where the first is a variadic template that can lock multiple mutexes, and the second is a member method to lock a single mutex.

Maybe a sync::mutex::lock would work?

This might apply to the std wrapper Mutex types too.

[sfackler]

Why is locking each mutex individually insufficient?

[toroidal-code]

Sequentially locking can cause deadlock with two threads:

Thread 1     Thread 2
lock A       lock B
lock B       lock A

[toroidal-code]

extern crate sync;
use sync::mutex::Mutex;

struct Node {
   mutex : Mutex
}
struct Link {
   to : &Node,
   from : &Node,
}

fn deadlock(link : &mut Link) {
  let to_guard = link.to.mutex.lock();
  let from_guard = link.from.mutex.lock();   // Deadlock can occur here
  drop(to_guard);
  drop(from_guard);
}

[bkoropoff]

The simplest solution to the problem you gave is to just lock the mutexes in address order. You could write a series of functions or methods on tuples of mutexes to do this. Example for pairs: http://is.gd/aNnVl5

This of course requires the order to be followed everywhere in the code, which can be difficult to verify.

[toroidal-code]

I'm working on a try-and-back-off method, based on libc++. I currently have locking for two mutexes, and am going to try generalizing it using macros tomorrow.
https://gist.github.com/toroidal-code/9c12d53a0f2d4e631cdd

[weswigham]

I feel like I've gotten close, but can't quite seem to get the macro functioning as I want it to: http://is.gd/EfLEIV

[toroidal-code]

Since sync::mutex::Mutex isn't even a thing anymore, I'm going to close this issue.