CODEWITHSUNDEEP
multithreadingconcurrencyrust
hydradon
hydradon

Reputation: 1436

Rust: concurrency error, program hangs after first thread

I have created a simplified version of my problem below, I have a Bag struct and Item struct. I want to spawn 10 threads that execute item_action method from Bag on each item in an item_list, and print a statement if both item's attributes are in the bag's attributes.

use std::sync::{Mutex,Arc};
use std::thread;

#[derive(Clone, Debug)]
struct Bag{
    attributes: Arc<Mutex<Vec<usize>>>
}

impl Bag {
    fn new(n: usize) -> Self {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            v.push(0);
        }

        Bag{
            attributes:Arc::new(Mutex::new(v)),
        }
}

    fn item_action(&self, item_attr1: usize, item_attr2: usize) -> Result<(),()> {

        if self.attributes.lock().unwrap().contains(&item_attr1) ||
        self.attributes.lock().unwrap().contains(&item_attr2) {

            println!("Item attributes {} and {} are in Bag attribute list!", item_attr1, item_attr2);
            Ok(())
        } else {
            Err(())
        }
    }
}

#[derive(Clone, Debug)]
struct Item{
    item_attr1: usize,
    item_attr2: usize,
}

impl Item{
    pub fn new(item_attr1: usize, item_attr2: usize) -> Self {
        Item{
            item_attr1: item_attr1,
            item_attr2: item_attr2
        }
    }
}

fn main() { 
    let mut item_list: Vec<Item> = Vec::new();
    for i in 0..10 { 
        item_list.push(Item::new(i, (i+1)%10));
    }

    let bag: Bag= Bag::new(10); //create 10 attributes

    let mut handles = Vec::with_capacity(10);

    for x in 0..10 {
        let bag2 = bag.clone();
        let item_list2= item_list.clone();

        handles.push(
            thread::spawn(move || {
                bag2.item_action(item_list2[x].item_attr1, item_list2[x].item_attr2);
            })
        )
    }

    for h in handles {
        println!("Here");
        h.join().unwrap();
    }
}

When running, I only got one line, and the program just stops there without returning. 

Item attributes 0 and 1 are in Bag attribute list!

May I know what went wrong? Please see code in Playground

Updated:

With suggestion from @loganfsmyth, the program can return now... but still only prints 1 line as above. I expect it to print 10 because my item_list has 10 items. Not sure if my thread logic is correct.

I have added println!("Here"); when calling join all threads. And I can see Here is printed 10 times, just not the actual log from item_action

Upvotes: 0

Views: 725

Answers (1)

loganfsmyth
loganfsmyth

Reputation: 161627

I believe this is because Rust is not running your 

if self.attributes.lock().unwrap().contains(&item_attr1) ||
    self.attributes.lock().unwrap().contains(&item_attr2) {

expression in the order you expect. The evaluation order of subexpressions in Rust is currently undefined. What appears to be happening is that you essentially end up with

const condition = {
  let lock1 = self.attributes.lock().unwrap();
  let lock2 = self.attributes.lock().unwrap();
  lock1.contains(&item_attr1) || lock2.contains(&item_attr2)
};
if condition {

which is causing your code to deadlock.

You should instead write:

let attributes = self.attributes.lock().unwrap();
if attributes.contains(&item_attr1) ||
   attributes.contains(&item_attr2) {

so that there is only one lock.

Your code would also work as-is if you used an RwLock or ReentrantMutex instead of a Mutex since those allow the same thread to have multiple immutable references to the data.

Upvotes: 1

Related Questions