當滿足一個條件時終止執行緒

我想有效地在兩個HashMaps的鍵上搜索一個值，一旦找到該值，就終止兩個執行緒。我目前正在使用兩個獨立的訊息通道（即兩個發射器和兩個接收器）來做這件事，但我不確定這是否是正確的方法。鑒于mpsc::channel的 "mpsc "組件代表 "多生產者，單消費者"，有多個生產者和多個消費者感覺不對。那么，有沒有一種更好的方法來同時搜索兩個陣列呢？

我的代碼也可在游樂場：

use std::collection::HashMap;
使用 std::array::IntoIter。
使用 std::thread;
使用 std::time::Duration。
use std::iter::FromIterator;
使用 std::sync::mpsc;

fn main（） {
    let m1 = HashMap::<_, _>::from_iter（IntoIter:: new([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ])。
    let m2 = HashMap::<_, _>::from_iter（IntoIter:: new([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10），（11，12）。(13, 14), (15, 16), (17,18), (19, 20) ] )。

    let (tx1, rx1) = mpsc::channel::<u8>（）。
    let (tx2, rx2) = mpsc::channel::<u8>（）。

    let handle1 = thread::spawn（move || {
        let iter_keys1 = m1.keys（）。
        for k in iter_keys1 {
            if k.clone() == 11u8 {
                tx2.send（*k）。
                break 
            } else {
                println!("Key from handle1: {}", k) 。
            }
            thread::sleep(Duration::from_millis(1) 。)
        }
        for received in rx1 {
            let into: u8 = received;
            if into == 11u8 {
                println!("handle2 sent a message to receiver1: {}", into) 。
                break。
            }
        }
        m1
    });

    let handle2 = thread::spawn（move || {
        let iter_keys2 = m2.keys（）。
        for k in iter_keys2 {
            if k.clone() == 11u8 {
                tx1.send（*k）。
                break 
            } else {
                println!("Key from handle2: {}", k) 。
            }
            thread::sleep(Duration::from_millis(1) 。)
        }
        for received in rx2 {
            let into: u8 = received;
            if into == 11u8 {
                println!("handle1向receiver2發送了一條資訊。{}", into）。)
                break。
            }
        }
        m2
    });
    handle1.join（）.unwrap（）。
    handle2.join().unwrap()。
}

有些相關的問題。使用sleep是否有實際的理由，或者這只是讓我們更容易看到小樣本上并發處理的結果？當我注釋掉thread::sleep(Duration::from_millis(1));行時，似乎執行緒是按順序處理的：

key from handle1: 9
來自handle1的鍵。5
來自handle1的鍵。3
來自handle1的鍵。1
來自handle1的鍵。7
來自handle2的密鑰：1。
handle2向receiver1發送了一條資訊。11

澄清：

我試圖搜索一個可能存在于兩個不同哈希圖中的鍵。在這個例子中，我在兩組鍵中搜索11，當我在任何一組鍵中找到它時，我想終止兩個執行緒。

uj5u.com熱心網友回復：

我正試圖搜索一個可能存在于兩個不同哈希圖中的鍵。在這個例子中，我在兩組鍵中搜索11，并希望在我在任何一組鍵中找到它時終止兩個執行緒。

在這種情況下，沒有理由使用mpsc來傳達停止條件。你可以使用一個簡單的原子bool：

use std::array::IntoIter;
使用 std::collection::HashMap。
使用 std::iter::FromIterator;
使用 std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
使用 std::thread;

fn main（） {
    let m1 = HashMap::<_, _>::from_iter（IntoIter:: new([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ])。
    let m2 = HashMap::<_, _>::from_iter(IntoIter::new([)
        (1, 2) 。
        (3, 4) 。
        (5, 6)。
        (7, 8)。
        (9, 10)。
        (11, 12)。
        (13, 14)。
        (15, 16)。
        (17, 18)。
        (19, 20)。
    ]));

    let stop_signal = Arc::new（AtomicBool。 :new(false)。

    let stop = stop_signal.clone（）。
    let h1 = thread::spawn(move || {
        let keys = m1.keys（）。
        for &k in keys {
            if stop.load(Order::Relaxed) {
                println!("Another thread found it!")。
                break。
            }

            if k == 11u8 {
                stop.store(true, Ordering::Relaxed)。
                //對找到的鍵做一些處理。
                println!("Found by thread 1")。
                break。
            }
        }
        m1
    });

    let stop = stop_signal.clone（）。
    let h2 = thread::spawn(move || {
        let keys = m2.keys（）。
        for &k in keys {
            if stop.load(Order::Relaxed) {
                println!("Another thread found it!")。
                break。
            }

            if k == 11u8 {
                stop.store(true, Ordering::Relaxed)。
                //對找到的鍵做一些處理。
                println!("Found by thread 2")。
                break。
            }
        }
        m2
    });

    h1.join（）.unwrap（）。
    h2.join（）.unwrap（）。
}

你的原始代碼有幾個問題：

標籤：

上一篇：在VisualBasic中，在ListBox中列出沒有檔案路徑的檔案

下一篇：如何同步三個相互依賴的任務的反復執行？