Dalam POC (Bukti Konsep) ini, kami akan meneroka bagaimana bahasa Rust merawat keadaan kaum, membandingkannya dengan C , bahasa yang digunakan secara meluas, tetapi dengan jaminan keselamatan yang lebih sedikit untuk persaingan.
Keselamatan Benang: Perlumbaan Data dari C hingga Karat
Dalam pengkomputeran, benang digunakan untuk membahagikan tugasan perisian kepada subtugas yang boleh dilaksanakan serentak. Dengan menggunakan benang, kami memperoleh masa pemprosesan dan menggunakan sumber mesin dengan lebih baik, tetapi persaingan ini membawa cabaran, seperti keadaan perlumbaan, yang boleh menjana ketidakkonsistenan yang serius dalam data.
Benang ialah unit pelaksanaan yang membolehkan anda memproses tugasan secara serentak. Kita boleh menganggap utas sebagai aliran pelaksanaan bebas dalam program, digambarkan dalam imej di bawah:
Walaupun urutan membawa kelebihan prestasi, ia memperkenalkan risiko, terutamanya apabila mengakses sumber yang dikongsi.
Selain itu, benang boleh digunakan untuk melaksanakan selari, di mana berbilang tugasan dilaksanakan serentak pada teras CPU yang berbeza. Ini membolehkan program menggunakan perkakasan yang tersedia dengan lebih baik, mempercepatkan pelaksanaan tugas bebas.
Mari kita buat sistem mudah dalam C:
int saldo = 1000;
void creditar(int valor) {
int tmp_saldo = saldo;
sleep(1); // Delay simulado
saldo += tmp_saldo + valor;
}
void debitar(int valor) {
int temp = saldo;
sleep(1); // Delay simulado
if (temp >= valor) {
saldo = temp - valor;
}
}
void* processar_transacao(void* arg) {
int valor = *(int*)arg;
if (valor > 0) {
creditar(valor);
} else {
debitar(abs(valor));
}
return NULL;
}
int main() {
int transactions[] = {100, -50, 200, -150, 300, -200, 150, -100, 50, -50};
int num_transactions = sizeof(transactions) / sizeof(transactions[0]);
pthread_t threads[num_transactions];
for (int i = 0; i < num_transactions; i++) {
pthread_create(&threads[i], NULL, processar_transacao, &transactions[i]); // Cria uma thread para cada transação
}
for (int i = 0; i < num_transactions; i++) {
pthread_join(threads[i], NULL); // Aguarda todas as threads terminarem
}
printf("Saldo final da conta: %d\n", saldo);
return 0;
}
Apabila kita memilih persekitaran dengan pemprosesan berbilang benang apa yang kita panggil keadaan perlumbaan boleh berlaku, apabila 2 utas mengakses dan mengubah suai nilai yang sama, kita mempunyai keadaan perlumbaan. Masalah ini berlaku kerana penyegerakan nilai yang diakses dalam setiap urutan tidak dijamin kerana persaingan antara panggilan.
Apabila melaksanakan kod ini beberapa kali, baki akhir berbeza-beza, kerana benang mengakses dan menukar baki secara serentak.
int saldo = 1000;
void creditar(int valor) {
int tmp_saldo = saldo;
sleep(1); // Delay simulado
saldo += tmp_saldo + valor;
}
void debitar(int valor) {
int temp = saldo;
sleep(1); // Delay simulado
if (temp >= valor) {
saldo = temp - valor;
}
}
void* processar_transacao(void* arg) {
int valor = *(int*)arg;
if (valor > 0) {
creditar(valor);
} else {
debitar(abs(valor));
}
return NULL;
}
int main() {
int transactions[] = {100, -50, 200, -150, 300, -200, 150, -100, 50, -50};
int num_transactions = sizeof(transactions) / sizeof(transactions[0]);
pthread_t threads[num_transactions];
for (int i = 0; i < num_transactions; i++) {
pthread_create(&threads[i], NULL, processar_transacao, &transactions[i]); // Cria uma thread para cada transação
}
for (int i = 0; i < num_transactions; i++) {
pthread_join(threads[i], NULL); // Aguarda todas as threads terminarem
}
printf("Saldo final da conta: %d\n", saldo);
return 0;
}
Mutex ialah primitif penyegerakan yang memastikan hanya satu urutan mempunyai akses kepada sumber yang dikongsi pada satu masa. Akronim mutex berasal daripada istilah Inggeris pengecualian bersama, yang bermaksud "pengecualian bersama".
Apabila thread memperoleh mutex, sebarang thread lain yang cuba memperoleh mutex yang sama digantung sehingga thread pertama mengeluarkan mutex. Ini menghalang dua atau lebih proses (benang) daripada mempunyai akses serentak kepada sumber yang dikongsi.
int saldo = 1000;
pthread_mutex_t saldo_mutex; // Mutex para proteger o saldo
void creditar(int valor) {
pthread_mutex_lock(&saldo_mutex); // Bloqueia o mutex
int tmp_saldo = saldo;
sleep(1); // Delay simulado
saldo = tmp_saldo + valor;
pthread_mutex_unlock(&saldo_mutex); // Libera o mutex
}
void debitar(int valor) {
pthread_mutex_lock(&saldo_mutex); // Bloqueia o mutex
int tmp_saldo = saldo;
sleep(1); // Delay simulado
if (tmp_saldo >= valor) {
saldo = tmp_saldo - valor;
}
pthread_mutex_unlock(&saldo_mutex); // Libera o mutex
}
Memikirkan Rust sebagai bahasa yang tidak terdapat dalam perlumbaan data tidak produktif, tetapi kita boleh memahami bagaimana menyusun dan penyusunnya menyumbang dengan membawa ciri hebat untuk ingatan dan keselamatan benang.
Karat merawat keadaan perlumbaan dengan jaminan masa kompilasi, menggunakan ciri seperti pemilikan, meminjam dan struktur selamat serentak:
Tanpa penggunaan struct Arc dan Mutex
Rust’s rich type system and ownership model guarantee memory-safety and thread-safety — enabling you to eliminate many classes of bugs at compile-time.
Karat tidak membenarkan akses terus kepada boleh ubah data (keseimbangan) daripada berbilang benang tanpa perlindungan.
Pengkompil akan menghasilkan ralat kerana baki sedang dialihkan ke berbilang utas (handle1 dan handle2) tanpa mekanisme yang selamat.
Mesej ralat yang akan dipaparkan ialah:
fn main() {
let mut saldo = 1000; // saldo mutável, mas sem proteção
let handle1 = thread::spawn(move || {
saldo += 100; // erro: `saldo` é movido para esta thread sem proteção
});
let handle2 = thread::spawn(move || {
saldo -= 50; // erro: `saldo` é movido para esta thread sem proteção
});
handle1.join().unwrap();
handle2.join().unwrap();
}
Menggunakan Mutex dan Arc kami dapat menyusun dan melaksanakan kod kami, dengan isu keadaan perlumbaan ditangani.
error[E0382]: use of moved value: `saldo`
Mutex dan RwLock digunakan untuk mengendalikan keadaan perlumbaan, masing-masing dengan kelebihan tertentu:
Mutex: Menjamin akses eksklusif kepada sumber untuk satu urutan, menyekat akses kepada yang lain sehingga ia dikeluarkan. Ia mudah dan berkesan, tetapi bacaan menyekat sumber, menjadikannya kurang cekap dalam senario bacaan berat.
RwLock: Membenarkan berbilang bacaan serentak dengan .read() dan mengehadkan penulisan eksklusif dengan .write(). Ia Ideal untuk senario dengan penguasaan bacaan, kerana ia meningkatkan prestasi dengan membenarkan keselarian dalam operasi bacaan.
Perbandingan antara C dan Rust menyerlahkan pendekatan yang berbeza untuk menyelesaikan keadaan perlumbaan. Walaupun C memerlukan perhatian untuk mengelakkan ralat keadaan perlumbaan, Rust mengurangkan risiko ini pada masa penyusunan, melalui alatan seperti Mutex, RwLock dan Arc sebagai tambahan kepada model pemilikan. Ini bukan sahaja menjadikan kod lebih selamat, tetapi juga mengurangkan beban mental pengaturcara dengan mengelakkan pepijat senyap.
Ringkasnya, Rust meletakkan dirinya sebagai pilihan terbaik untuk membangunkan sistem bersaing, menawarkan keselamatan dan kebolehpercayaan.
Atas ialah kandungan terperinci Keselamatan Benang Karat: Perbandingan dengan C.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Apakah bahasa pengaturcaraan bahasa c?
tukar penggunaan penyata
Perisian pemulihan data percuma
Perbezaan antara vue2.0 dan 3.0
Bagaimana untuk mencipta folder baharu dalam pycharm
Bagaimana untuk menyelesaikan ralat parsererror
Bagaimana untuk memohon pendaftaran alamat e-mel
Bagaimana untuk memasuki laman web 404
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
