6.1 哲学家就餐

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/concurrency/sync-exercises/dining-philosophers.html

6.1 哲学家就餐

哲学家就餐问题是并发领域的经典问题：

五位哲学家同桌用餐。每位哲学家有自己的座位。每两个盘子之间有一根筷子。菜是意大利面，需要两根筷子才能吃。每位哲学家只能交替思考与进食。而且，只有同时拿到左右两根筷子时，哲学家才能吃面。因此，只有当左右邻居都在思考、而不是在进食时，两根筷子才可用。某位哲学家吃完后，会放下两根筷子。

6.2 多线程链接检查器

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/concurrency/sync-exercises/link-checker.html

6.2 多线程链接检查器

让我们用新知识做一个多线程链接检查器。它应从某个网页开始，检查页面上的链接是否有效；再递归检查同一域名上的其他页面，直到所有页面都验证完毕。

6.3 题解

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/concurrency/sync-exercises/solutions.html

6.3 题解

哲学家就餐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::sync::{Arc, Mutex, mpsc};
use std::thread;
use std::time::Duration;

struct Chopstick;

struct Philosopher {
 name: String,
 left_chopstick: Arc<Mutex<Chopstick>>,
 right_chopstick: Arc<Mutex<Chopstick>>,
 thoughts: mpsc::SyncSender<String>,
}

impl Philosopher {
 fn think(&self) {
 self.thoughts
 .send(format!("Eureka! {} has a new idea!", &self.name))
 .unwrap();
 }

 fn eat(&self) {
 println!("{} is trying to eat", &self.name);
 let _left = self.left_chopstick.lock().unwrap();
 let _right = self.right_chopstick.lock().unwrap();

 println!("{} is eating...", &self.name);
 thread::sleep(Duration::from_millis(10));
 }
}

static PHILOSOPHERS: &[&str] =
 &["Socrates", "Hypatia", "Plato", "Aristotle", "Pythagoras"];

fn main() {
 let (tx, rx) = mpsc::sync_channel(10);

 let chopsticks = PHILOSOPHERS
 .iter()
 .map(|_| Arc::new(Mutex::new(Chopstick)))
 .collect::<Vec<_>>();

 for i in 0..chopsticks.len() {
 let tx = tx.clone();
 let mut left_chopstick = Arc::clone(&chopsticks[i]);
 let mut right_chopstick =
 Arc::clone(&chopsticks[(i + 1) % chopsticks.len()]);

 // 为避免死锁，必须在某处打破对称。
 // 这会交换筷子而不反初始化它们。
 if i == chopsticks.len() - 1 {
 std::mem::swap(&mut left_chopstick, &mut right_chopstick);
 }

 let philosopher = Philosopher {
 name: PHILOSOPHERS[i].to_string(),
 thoughts: tx,
 left_chopstick,
 right_chopstick,
 };

 thread::spawn(move || {
 for _ in 0..100 {
 philosopher.eat();
 philosopher.think();
 }
 });
 }

 drop(tx);
 for thought in rx {
 println!("{thought}");
 }
}

链接检查器

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161


// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::sync::{Arc, Mutex, mpsc};
use std::thread;

use reqwest::Url;
use reqwest::blocking::Client;
use scraper::{Html, Selector};
use thiserror::Error;

#[derive(Error, Debug)]
enum Error {
 #[error("request error: {0}")]
 ReqwestError(#[from] reqwest::Error),
 #[error("bad http response: {0}")]
 BadResponse(String),
}

#[derive(Debug)]
struct CrawlCommand {
 url: Url,
 extract_links: bool,
}

fn visit_page(client: &Client, command: &CrawlCommand) -> Result<Vec<Url>, Error> {
 println!("Checking {:#}", command.url);
 let response = client.get(command.url.clone()).send()?;
 if !response.status().is_success() {
 return Err(Error::BadResponse(response.status().to_string()));
 }

 let mut link_urls = Vec::new();
 if !command.extract_links {
 return Ok(link_urls);
 }

 let base_url = response.url().clone();
 let body_text = response.text()?;
 let document = Html::parse_document(&body_text);

 let selector = Selector::parse("a").unwrap();
 let href_values = document
 .select(&selector)
 .filter_map(|element| element.value().attr("href"));
 for href in href_values {
 match base_url.join(href) {
 Ok(link_url) => {
 link_urls.push(link_url);
 }
 Err(err) => {
 println!("On {base_url:#}: ignored unparsable {href:?}: {err}");
 }
 }
 }
 Ok(link_urls)
}

struct CrawlState {
 domain: String,
 visited_pages: std::collections::HashSet<String>,
}

impl CrawlState {
 fn new(start_url: &Url) -> CrawlState {
 let mut visited_pages = std::collections::HashSet::new();
 visited_pages.insert(start_url.as_str().to_string());
 CrawlState { domain: start_url.domain().unwrap().to_string(), visited_pages }
 }

 /// 判断是否应提取给定页面内的链接。
 fn should_extract_links(&self, url: &Url) -> bool {
 url.domain().is_some_and(|d| d == self.domain)
 }

 /// 将给定页面标记为已访问；若此前已访问过则返回 false。
 fn mark_visited(&mut self, url: &Url) -> bool {
 self.visited_pages.insert(url.as_str().to_string())
 }
}

type CrawlResult = Result<Vec<Url>, (Url, Error)>;

fn spawn_crawler_threads(
 command_receiver: mpsc::Receiver<CrawlCommand>,
 result_sender: mpsc::Sender<CrawlResult>,
 thread_count: u32,
) {
 // 为多路复用不可 Clone 的 Receiver，将其包在 Arc<Mutex<_>> 中。
 let command_receiver = Arc::new(Mutex::new(command_receiver));

 for _ in 0..thread_count {
 let result_sender = result_sender.clone();
 let command_receiver = Arc::clone(&command_receiver);
 thread::spawn(move || {
 let client = Client::new();
 loop {
 let command_result = {
 let receiver_guard = command_receiver.lock().unwrap();
 receiver_guard.recv()
 };
 let Ok(crawl_command) = command_result else {
 // 发送端已丢弃。不会再有新命令。
 break;
 };
 let crawl_result = match visit_page(&client, &crawl_command) {
 Ok(link_urls) => Ok(link_urls),
 Err(error) => Err((crawl_command.url, error)),
 };
 result_sender.send(crawl_result).unwrap();
 }
 });
 }
}

fn control_crawl(
 start_url: Url,
 command_sender: mpsc::Sender<CrawlCommand>,
 result_receiver: mpsc::Receiver<CrawlResult>,
) -> Vec<Url> {
 let mut crawl_state = CrawlState::new(&start_url);
 let start_command = CrawlCommand { url: start_url, extract_links: true };
 command_sender.send(start_command).unwrap();
 let mut pending_urls = 1;

 let mut bad_urls = Vec::new();
 while pending_urls > 0 {
 let crawl_result = result_receiver.recv().unwrap();
 pending_urls -= 1;

 match crawl_result {
 Ok(link_urls) => {
 for url in link_urls {
 if crawl_state.mark_visited(&url) {
 let extract_links = crawl_state.should_extract_links(&url);
 let crawl_command = CrawlCommand { url, extract_links };
 command_sender.send(crawl_command).unwrap();
 pending_urls += 1;
 }
 }
 }
 Err((url, error)) => {
 bad_urls.push(url);
 println!("Got crawling error: {:#}", error);
 }
 }
 }
 bad_urls
}

fn check_links(start_url: Url) -> Vec<Url> {
 let (result_sender, result_receiver) = mpsc::channel::<CrawlResult>();
 let (command_sender, command_receiver) = mpsc::channel::<CrawlCommand>();
 spawn_crawler_threads(command_receiver, result_sender, 16);
 control_crawl(start_url, command_sender, result_receiver)
}

fn main() {
 let start_url = reqwest::Url::parse("https://www.google.org").unwrap();
 let bad_urls = check_links(start_url);
 println!("Bad URLs: {:#?}", bad_urls);
}

6 练习 on 编程那些事儿

6.1 哲学家就餐

6.1 哲学家就餐

6.2 多线程链接检查器

6.2 多线程链接检查器

6.3 题解

6.3 题解

哲学家就餐

链接检查器