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 Karat: Perbandingan dengan C

Keselamatan Benang: Perlumbaan Data dari C hingga Karat

Indeks

• 1. Pengenalan
• 2. Benang
• 3. Pelaksanaan dalam C
  • 3.1. Kod tanpa Perlindungan Terhadap Keadaan Perlumbaan
  • 3.2. Membetulkan dengan Mutex
• 4. Pelaksanaan dalam Karat
  • 4.1. Masalah dengan Keadaan Perlumbaan
  • 4.2. Resolusi dengan Mutex dan Arc
  • 4.3. Mutex lwn. RwLock
• 5. Kesimpulan
• 6. Rujukan

1. Pengenalan

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.

2. Benang

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.

3. Pelaksanaan dalam C

Mari kita buat sistem mudah dalam C:

1. Baki awal 1000.
2. Satu set transaksi yang boleh berupa kredit atau debit.
3. Pemprosesan selari transaksi ini menggunakan urutan.

3.1. Kod tanpa Perlindungan Terhadap Keadaan Perlumbaan

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.

3.2. Membetulkan dengan Mutex

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.

4. Pelaksanaan dalam Karat

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:

• Arka: Perkongsian selamat bagi data tidak berubah.
• Mutex dan RwLock: Kawalan akses untuk data boleh ubah.

4.1. Masalah dengan Keadaan Perlumbaan

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();
}

4.2. Resolusi dengan Mutex dan Arc

Menggunakan Mutex dan Arc kami dapat menyusun dan melaksanakan kod kami, dengan isu keadaan perlumbaan ditangani.

error[E0382]: use of moved value: `saldo`

4.3. Mutex lwn. RwLock

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.

5. Kesimpulan

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.

6. Rujukan

• Repo dengan kod: https://github.com/z4nder/rust-data-races
• https://ms.wikipedia.org/wiki/Race_condition
• https://blog.bughunt.com.br/o-que-sao-vulnerabilidades-race-condition/
• https://medium.com/cwi-software/spring-boot-race-condition-e-ambiente-multi-thread-263b21e0042e
• https://learn.microsoft.com/en-us/troubleshoot/developer/visualstudio/visual-basic/language-compilers/race-conditions-deadlocks
• https://www.reddit.com/r/rust/comments/18faxjg/understanding_threadsafety_vs_race_conditions/?rdt=52263
• https://doc.rust-lang.org/nomicon/races.html
• https://news.ycombinator.com/item?id=23599598

Atas ialah kandungan terperinci Keselamatan Benang Karat: Perbandingan dengan C.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!