Rustのプログラミング言語は、独自の所有権システムと型システムを通じて、安全性とパフォーマンスを両立させた設計が特徴です。特にマルチスレッド環境において、データ不変性の概念を活用することで、データ競合やメモリ管理の問題を未然に防ぎつつ、効率的な並行処理を実現できます。本記事では、Rustのデータ不変性の基本概念から、具体的なマルチスレッド設計の手法、安全な共有メモリ管理、そしてメッセージパッシングを用いた実装方法までを網羅的に解説します。これにより、マルチスレッドプログラミングの課題を克服し、Rustの強力な機能を最大限に活用する方法を学びます。
Rustにおけるデータ不変性とは
データ不変性とは、一度生成されたデータの状態を変更できない性質を指します。Rustではこの概念が、所有権と借用という独自のメモリ管理システムに密接に関連しています。Rustでは、デフォルトで変数がイミュータブル（不変）であるため、他のスレッドやコンポーネントから意図しない変更が加えられるリスクが大幅に軽減されます。
所有権と借用の基本
Rustの所有権モデルは、1つのデータに対して明確な所有者を持つというルールに基づいています。このルールにより、データのライフタイムが明確に管理され、データ競合や解放済みメモリへのアクセスといった問題を回避できます。
また、借用では、参照を通じてデータを操作できるようにしつつ、不変性を保持したまま安全に共有する仕組みを提供します。
データ不変性がもたらす利点
- データ競合の防止: イミュータブルなデータは複数のスレッド間で安全に共有できます。
- コードの明確化: 変更可能なデータの範囲が明示されるため、コードの読みやすさが向上します。
- 予測可能性の向上: 状態が不変であることにより、プログラムの挙動が予測しやすくなります。
Rustのデータ不変性を支える機能
Rustでは、以下の機能を利用してデータ不変性を確保します。
letキーワード: デフォルトで変数をイミュータブルにします。ArcとRc: 参照カウントを用いた安全な共有を実現します。- 型システム: 不変性や所有権の違反をコンパイル時に検出します。
これらの機能により、Rustでは高い信頼性と効率性を持つプログラムを構築できます。
マルチスレッドプログラミングの課題
マルチスレッドプログラミングは、複数のスレッドが同時に作業を行うことで効率を向上させる手法ですが、それに伴い特有の課題も発生します。データ競合やスレッド間の同期問題は、適切に対処しないと深刻なバグを引き起こす可能性があります。
データ競合
データ競合とは、複数のスレッドが同じデータに同時にアクセスし、そのうち少なくとも1つがデータを変更しようとする状況を指します。この状態では、スレッド間で予期しない挙動やデータ破損が発生します。
例：
use std::thread;
fn main() {
let mut data = 0;
let handle = thread::spawn(move || {
data += 1; // 他のスレッドが同時にアクセスするとデータ競合が発生
});
handle.join().unwrap();
println!("data: {}", data);
}デッドロック
デッドロックは、複数のスレッドが互いにリソースを待機している状態から進行できなくなる問題です。この状態ではプログラムが停止する可能性があります。
共有データの同期
スレッド間で共有されるデータの一貫性を保つためには、同期機構を用いる必要があります。しかし、同期を誤ると、リソースの競合やパフォーマンスの低下を招くことがあります。
スレッド管理の難しさ
スレッドの作成や終了の管理、ライフタイムの設定は、複雑なプログラムで特に困難になります。これにより、不要なスレッドが増加してリソースを浪費したり、プログラム全体が不安定になるリスクがあります。
Rustでの課題解決
Rustの所有権モデルや型システムは、これらの課題を軽減する設計になっています。具体的には以下のような方法で対処します。
- 所有権によるデータ管理: 所有権と借用ルールがデータ競合を防ぎます。
- スレッド安全な型: Rustでは
SendやSyncトレイトを用いて、スレッド間のデータ共有の安全性を保証します。 - 同期プリミティブの提供:
MutexやRwLockを利用して、スレッド間の安全な同期を実現します。
次項では、Rustが提供するこれらの機能を活用して、安全なマルチスレッド設計を行う方法について解説します。
Rustが提供する安全なスレッド管理の仕組み
Rustは、そのユニークな所有権モデルと型システムを通じて、マルチスレッド環境での安全性を強力に保証します。これにより、データ競合や不正なメモリアクセスを未然に防ぐことが可能です。
所有権モデルとスレッド安全性
Rustの所有権モデルは、1つのデータに対して明確な所有者を持つというルールに基づいています。このモデルにより、スレッド間でデータが誤って共有されたり、競合が発生するリスクを低減できます。
例:
use std::thread;
fn main() {
let data = String::from("Rust");
let handle = thread::spawn(move || {
println!("Hello from the thread: {}", data); // moveを指定して所有権を移動
});
handle.join().unwrap();
}moveキーワードを用いることで、スレッドが必要とするデータの所有権を安全に移動できます。
`Send`と`Sync`トレイト
Rustでは、スレッド間で安全にデータを転送できるかどうかをSendトレイトが決定します。また、データが複数のスレッドから同時にアクセスされる場合の安全性はSyncトレイトが保証します。
Sendトレイト: データの所有権を他のスレッドに移すことが可能であることを示します。Syncトレイト: データを複数のスレッドから同時に参照可能であることを示します。
これらのトレイトが実装されていない型は、スレッド安全性が保証されないため、コンパイル時にエラーが発生します。
同期プリミティブの利用
Rustは以下のような同期プリミティブを提供し、スレッド間のデータ共有を安全に管理します。
Mutex: 共有データへの排他的アクセスを提供する同期プリミティブ。
use std::sync::Mutex;
use std::thread;
fn main() {
let data = Mutex::new(0);
let handles: Vec<_> = (0..10).map(|_| {
let data = data.clone();
thread::spawn(move || {
let mut num = data.lock().unwrap();
*num += 1;
})
}).collect();
for handle in handles {
handle.join().unwrap();
}
println!("Result: {:?}", *data.lock().unwrap());
}Arc（Atomic Reference Counting）: 参照カウントを用いてデータを安全に共有する。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let data = Arc::new(Mutex::new(0));
let handles: Vec<_> = (0..10).map(|_| {
let data = Arc::clone(&data);
thread::spawn(move || {
let mut num = data.lock().unwrap();
*num += 1;
})
}).collect();
for handle in handles {
handle.join().unwrap();
}
println!("Result: {:?}", *data.lock().unwrap());
}所有権モデルと同期プリミティブの統合
Rustでは、所有権と同期プリミティブを組み合わせることで、明確で安全なスレッド設計が可能です。これにより、データ不変性を保ちながら効率的にマルチスレッドプログラミングを行うことができます。
次項では、データ不変性を活用した具体的な並行処理の例を紹介します。
データ不変性を利用した並行処理の基本例
Rustのデータ不変性と所有権モデルを活用することで、安全で効率的な並行処理を実現できます。ここでは、具体的なRustコードを使い、データ不変性を保ちながら複数スレッドで作業を分担する基本例を紹介します。
データ不変性を用いた簡単な並行処理
Rustのthread::spawn関数を使用し、複数スレッドで不変データを処理する例を示します。
use std::thread;
fn main() {
let data = vec![1, 2, 3, 4, 5]; // 不変データ
let handles: Vec<_> = data.iter()
.map(|&num| {
thread::spawn(move || {
println!("Thread processing number: {}", num);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}このコードでは、dataが不変であるため、各スレッドで安全に共有できます。moveキーワードを使用して、スレッドに渡すデータの所有権を移動しています。
並列計算の例: データ不変性と所有権
以下は、データ不変性を活用してリストの要素を並列に計算する例です。
use std::thread;
fn main() {
let numbers = vec![1, 2, 3, 4, 5];
let mut handles = vec![];
for &num in &numbers {
let handle = thread::spawn(move || {
let result = num * num; // 各スレッドで計算
println!("Square of {} is {}", num, result);
result
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
}この例では、各スレッドがリストの異なる要素に対して計算を行います。データが不変であるため、データ競合が発生しません。
`Arc`とデータ共有
共有データを扱う場合にはArc（Atomic Reference Counting）を使用します。以下は、複数スレッドで共有データを安全に処理する例です。
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let handles: Vec<_> = (0..data.len())
.map(|i| {
let data = Arc::clone(&data);
thread::spawn(move || {
println!("Thread {} processing number: {}", i, data[i]);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}Arcを使用することで、複数のスレッドが安全に同じデータを参照できます。データは不変であるため、スレッド間での競合は発生しません。
安全な並行処理のポイント
- 不変データはスレッド間で安全に共有可能。
- 可変データを共有する場合は、
ArcとMutexを組み合わせて使用する。 moveキーワードを使用してデータの所有権を明示的に移動する。
次項では、マルチスレッド環境での共有メモリの扱い方についてさらに詳しく解説します。
マルチスレッドと共有メモリ
マルチスレッドプログラミングでは、スレッド間でデータを共有する必要が生じる場合があります。RustではArcやMutexといったプリミティブを用いることで、安全に共有メモリを管理できます。これにより、データ競合や不整合を回避しながらスレッド間の効率的なデータ共有が可能です。
`Arc`による共有メモリ管理
Arc（Atomic Reference Counting）は、複数のスレッド間でデータを安全に共有するためのスマートポインタです。Rcと異なり、スレッドセーフであり、データ競合を防ぎます。
例: 複数スレッドでリストを共有する
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let handles: Vec<_> = (0..data.len())
.map(|i| {
let data = Arc::clone(&data);
thread::spawn(move || {
println!("Thread {} processing number: {}", i, data[i]);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}この例では、Arc::cloneを使用してスレッド間でデータを共有しています。データが不変であるため、スレッド間で安全にアクセスできます。
`Mutex`を用いた共有メモリの排他制御
Mutex（Mutual Exclusion）は、共有メモリに対する排他的アクセスを提供するプリミティブです。複数のスレッドが同時に共有データを変更する場合に使用します。
例: カウンタを複数スレッドで更新する
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let handles: Vec<_> = (0..10)
.map(|_| {
let counter = Arc::clone(&counter);
thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
println!("Final counter value: {}", *counter.lock().unwrap());
}このコードでは、Mutexを使用してカウンタの更新操作を保護しています。lock()メソッドを使用してロックを取得し、排他的にデータを操作します。
`RwLock`を用いた効率的な共有
RwLock（Read-Write Lock）は、複数のスレッドから読み取りを許可しつつ、書き込み時には排他制御を行います。
例: データの効率的な共有
use std::sync::{Arc, RwLock};
use std::thread;
fn main() {
let data = Arc::new(RwLock::new(vec![1, 2, 3]));
let handles: Vec<_> = (0..3)
.map(|i| {
let data = Arc::clone(&data);
thread::spawn(move || {
let mut write_access = data.write().unwrap();
write_access.push(i + 4);
println!("Thread {} updated the vector: {:?}", i, *write_access);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
println!("Final data: {:?}", *data.read().unwrap());
}RwLockを使うことで、必要に応じて読み取りと書き込みを切り替えながら効率的にデータを操作できます。
共有メモリを扱う際の注意点
- 過度なロックの使用はデッドロックや性能低下を招く可能性がある。
- ロック取得後は必ずスコープ内で解放する。
- 共有データへのアクセス頻度や用途に応じて、
MutexとRwLockを適切に使い分ける。
次項では、メッセージパッシングを用いたマルチスレッド設計手法について解説します。
メッセージパッシングを使った設計手法
Rustでは、スレッド間のデータ共有において、共有メモリの代替としてメッセージパッシングを利用することが推奨される場合があります。この方法は、データ競合やロックによる問題を回避し、スレッド間の通信を効率的に行うために設計されています。
メッセージパッシングの基本概念
メッセージパッシングは、スレッド間で共有メモリを直接操作するのではなく、メッセージを送受信する仕組みを利用してデータを交換する手法です。Rustでは、標準ライブラリのmpsc（マルチプロデューサ、シングルコンシューマ）チャネルを使用してこの通信を実現します。
`mpsc`を用いたシンプルなメッセージパッシング
以下は、複数のスレッドからメッセージを送信し、1つのスレッドで受信する基本的な例です。
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
for i in 1..5 {
let tx = tx.clone();
thread::spawn(move || {
tx.send(format!("Message {}", i)).unwrap();
thread::sleep(Duration::from_millis(100));
});
}
for received in rx {
println!("Received: {}", received);
}
}このコードでは、複数のスレッドが送信したメッセージを1つのスレッドが順次受信しています。tx.clone()を使用して送信チャネルを複製し、複数スレッドで使用可能にしています。
送受信の非同期処理
メッセージパッシングを活用することで、非同期処理も実現できます。以下は非同期な計算結果をスレッド間でやり取りする例です。
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
for i in 1..=5 {
tx.send(i * 10).unwrap();
}
});
for result in rx {
println!("Computed result: {}", result);
}
}この例では、スレッド内で計算された結果が順次受信側に送られ、他のスレッドがその結果を利用しています。
メッセージパッシングの利点
- データ競合の回避: メッセージを介してデータを交換するため、スレッド間での競合が発生しない。
- シンプルな設計: データ共有とスレッドのライフタイム管理を明確に分離可能。
- スケーラビリティ: メッセージ送信元や受信先を柔軟に拡張できる。
ケーススタディ: ワーカースレッドとタスク分散
メッセージパッシングを用いてワーカースレッドを構築し、タスクを分散する例を示します。
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
for i in 0..3 {
let rx = rx.clone();
thread::spawn(move || {
while let Ok(task) = rx.recv() {
println!("Worker {} processing task: {}", i, task);
}
});
}
for task in 1..10 {
tx.send(task).unwrap();
}
}このコードでは、タスクを複数のワーカースレッドに分散させる仕組みを構築しています。これにより、タスクを並列に処理できます。
設計上の注意点
- 受信側のブロック: 受信スレッドがメッセージを待ち続けることでデッドロックが発生しないよう注意する。
- 送信側の停止検出: 送信者が全て終了した場合、受信者が正しく終了するよう設計する。
次項では、データ不変性を活用したパフォーマンス最適化の手法について解説します。
データ不変性を利用したパフォーマンス最適化
Rustのデータ不変性は、安全性を提供するだけでなく、パフォーマンス向上にも寄与します。データ不変性を活用することで、効率的な並行処理や計算負荷の分散を実現できます。本節では、データ不変性を用いたパフォーマンス最適化の手法を具体的に解説します。
共有データを複製しない設計
データが不変である場合、複数のスレッドで安全に共有できるため、データを複製する必要がなくなります。これにより、メモリ使用量を削減し、処理速度を向上させます。
例: 不変データの共有
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![1, 2, 3, 4, 5]);
let handles: Vec<_> = (0..5)
.map(|i| {
let data = Arc::clone(&data);
thread::spawn(move || {
println!("Thread {} received data: {}", i, data[i]);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}この例では、Arcを使用することで、複数のスレッドが安全に同じデータを参照し、余計なデータコピーを回避しています。
データ不変性を用いたキャッシュの利用
データが変更されない場合、キャッシュを積極的に利用することができます。これにより、計算結果を再利用し、処理時間を短縮できます。
例: 計算結果をキャッシュする
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let cache = Arc::new(Mutex::new(HashMap::new()));
let handles: Vec<_> = (1..=5)
.map(|num| {
let cache = Arc::clone(&cache);
thread::spawn(move || {
let mut cache = cache.lock().unwrap();
if let Some(&result) = cache.get(&num) {
println!("Cache hit for {}: {}", num, result);
} else {
let result = num * num; // 計算
cache.insert(num, result);
println!("Computed for {}: {}", num, result);
}
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}この例では、計算結果をキャッシュに保存し、同じ計算を繰り返さないようにしています。
メッセージパッシングとデータ不変性の組み合わせ
メッセージパッシングを利用する場合も、不変データであれば効率的に処理を分配できます。以下は、ワーカースレッド間でタスクを分散する例です。
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
let data = vec![1, 2, 3, 4, 5];
let handle = thread::spawn(move || {
for num in data {
tx.send(num * num).unwrap();
}
});
for received in rx {
println!("Processed: {}", received);
}
handle.join().unwrap();
}この例では、データが変更されないため、スレッド間で効率的に処理を分配できます。
イテレータを活用した効率的な処理
Rustのイテレータは、データ不変性と相性が良く、高速かつ安全なデータ処理を可能にします。
例: イテレータによる並列処理
use rayon::prelude::*;
fn main() {
let data = vec![1, 2, 3, 4, 5];
let results: Vec<_> = data.par_iter()
.map(|&num| num * num)
.collect();
println!("Results: {:?}", results);
}このコードでは、rayonクレートを使用してイテレータを並列に処理しています。データ不変性のおかげで、並列処理中も安全性が保証されます。
データ不変性を活用する際の注意点
- 不要なロックを避ける: 不変データであれば、ロックを最小限に抑える設計が可能。
Arcとイテレータの併用:Arcでデータを共有し、イテレータで効率的に処理する。- 計算負荷を均等に分散: 並列処理時に負荷が偏らないよう設計する。
次項では、スレッドプールの構築例を紹介し、効率的なマルチスレッド設計の具体例を解説します。
実例：スレッドプールの構築
スレッドプールは、一定数のスレッドを再利用して効率的にタスクを処理するための設計パターンです。Rustでは標準ライブラリを活用して、自作のスレッドプールを構築することが可能です。本節では、スレッドプールの構築手法とその利点を具体的に解説します。
スレッドプールの基本設計
スレッドプールは、あらかじめ固定数のスレッドを作成し、タスクをキューに入れて処理する仕組みです。この設計により、スレッド作成のオーバーヘッドを抑えつつ、並列処理の効率を向上させます。
例: 基本的なスレッドプールの構築
以下は、シンプルなスレッドプールを構築する例です。
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
struct ThreadPool {
workers: Vec<Worker>,
sender: mpsc::Sender<Job>,
}
type Job = Box<dyn FnOnce() + Send + 'static>;
impl ThreadPool {
fn new(size: usize) -> ThreadPool {
assert!(size > 0);
let (sender, receiver) = mpsc::channel();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for id in 0..size {
workers.push(Worker::new(id, Arc::clone(&receiver)));
}
ThreadPool { workers, sender }
}
fn execute<F>(&self, f: F)
where
F: FnOnce() + Send + 'static,
{
let job = Box::new(f);
self.sender.send(job).unwrap();
}
}
struct Worker {
id: usize,
thread: Option<thread::JoinHandle<()>>,
}
impl Worker {
fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
let thread = thread::spawn(move || loop {
let job = receiver.lock().unwrap().recv().unwrap();
println!("Worker {} executing a job", id);
job();
});
Worker {
id,
thread: Some(thread),
}
}
}スレッドプールの利用例
上記のスレッドプールを使って、複数のタスクを並列に処理する例を示します。
fn main() {
let pool = ThreadPool::new(4);
for i in 0..8 {
pool.execute(move || {
println!("Processing task {}", i);
});
}
// 適切に終了するために、メインスレッドでの待機が必要
std::thread::sleep(std::time::Duration::from_secs(1));
}この例では、8つのタスクが4つのスレッドで並列に処理されます。
スレッドプールの利点
- 効率的なリソース利用: スレッド作成のオーバーヘッドを削減。
- スケーラビリティ: 多数のタスクを効率的に処理可能。
- 柔軟性: キューにタスクを追加することで、新しい仕事をスレッドに割り当てられる。
スレッドプールの拡張例
以下は、スレッドプールに停止機能を追加する例です。
impl ThreadPool {
fn stop(self) {
for worker in self.workers {
if let Some(thread) = worker.thread {
thread.join().unwrap();
}
}
}
}スレッドプールが適切に終了するようにすることで、リソースリークを防止できます。
注意点
- 適切なサイズ設定: スレッド数が多すぎるとスケジュールオーバーヘッドが発生。
- ジョブキューの容量: キューのサイズを設計に応じて調整する必要あり。
- エラーハンドリング: タスクの実行中にエラーが発生しても、スレッドプール全体が停止しないようにする。
次項では、実践的な演習問題を通じて、学んだ内容を活用する方法を紹介します。
演習問題：マルチスレッドのコード設計
ここでは、Rustで学んだマルチスレッド設計の知識を実践するための演習問題を提示します。これらの演習を通じて、データ不変性、所有権モデル、スレッドプール、共有メモリ管理などの理解を深めましょう。
演習問題 1: スレッド間での安全なデータ共有
問題: 以下の要件を満たすプログラムを作成してください。
- 数値の配列をスレッド間で共有する。
- 各スレッドが配列の異なる要素を平方計算し、その結果をメインスレッドに返す。
- 結果を全て受信し、コンソールに出力する。
ヒント:
mpscチャネルを使用。- 配列の要素を不変データとして扱う。
期待される出力例
Thread 1: 1^2 = 1
Thread 2: 2^2 = 4
Thread 3: 3^2 = 9
... 演習問題 2: スレッドプールの改良
問題: 以前構築したスレッドプールを改良し、以下の機能を追加してください。
- タスクキューに上限を設定し、溢れた場合にエラーメッセージを出力する。
- タスクの実行中にエラーが発生した場合も他のタスクの処理を継続する。
ヒント:
- タスクキューのサイズ制御には
VecDequeやSemaphoreを活用。 - エラーハンドリングには
Result型を使用。
期待される出力例
Worker 1: Task executed successfully
Worker 2: Task failed with error: Invalid input
... 演習問題 3: メッセージパッシングによる並列タスク分配
問題: 3つのワーカースレッドを持つシステムを設計してください。
- メインスレッドがタスク（例: 数値の計算）をワーカースレッドに分配する。
- ワーカースレッドが計算結果をメインスレッドに返す。
- 全ての計算が終了したら、メインスレッドが結果を表示する。
ヒント:
- メインスレッドからのタスク送信に
mpsc::Senderを使用。 - ワーカースレッドからの結果送信に別の
mpsc::Senderを使用。
期待される出力例
Task 1 assigned to Worker 1
Task 2 assigned to Worker 2
Task 3 assigned to Worker 3
Results: [25, 49, 64] 演習のポイント
これらの演習を通じて以下を意識してください。
- Rustの所有権モデルを適切に利用しているか。
- 競合を防ぐために、
ArcやMutexを正しく活用しているか。 - プログラムがスレッドセーフかつ効率的に設計されているか。
次項では、これらの内容を振り返り、学びを総括します。
まとめ
本記事では、Rustのデータ不変性を活用したマルチスレッド設計について、基礎から応用までを解説しました。Rustが提供する所有権モデルや型システムにより、安全で効率的なマルチスレッドプログラミングが可能であることを学びました。
また、ArcやMutexを用いた共有メモリの管理、mpscによるメッセージパッシング、さらにはスレッドプールの構築例を通じて、並列処理の具体的な実装方法を深掘りしました。最後に演習問題を通じて、理論を実践に応用する機会も提供しました。
Rustの特徴であるデータ不変性は、安全性だけでなく、パフォーマンス最適化にも役立ちます。これを活用することで、複雑な並行処理を行うアプリケーションでも、安定性と効率性を兼ね備えた設計が可能です。
Rustを使用してさらに高度なマルチスレッドプログラミングに挑戦し、実践を通じてスキルを高めてください。
コメント