Rust 线​​程安全性：与 C 的比较。

在这个POC（概念证明）中，我们将探索Rust语言如何处理竞争条件，并将其与C ，一种广泛使用的语言，但竞争的安全保障较少。

Rust 线​​程安全性：与 C 的比较

线程安全：从 C 到 Rust 的数据竞争

指数

一、简介
2. 线程
3. C 语言的实现
• 3.1.没有针对竞争条件的保护的代码
  3.2.使用互斥体修复
4. Rust 中的实现
• 4.1.竞争条件问题
  4.2.互斥体和弧的解析
  4.3.互斥体对比读写锁
5. 结论
6. 参考文献

---

一、简介

在计算中，

线程用于将软件任务划分为可以并发执行的子任务。通过使用线程，我们获得了处理时间并更好地利用机器的资源，但这种竞争带来了挑战，例如竞争条件，这可能会产生数据的严重不一致。

---

2. 线程

线程是允许您同时处理任务的执行单元。我们可以将线程视为程序内独立的执行流，如下图所示：

虽然线程带来了性能优势，但它们也带来了风险，尤其是在访问共享资源时。

此外，线程还可以用来实现并行性，即多个任务在不同的CPU核心上同时执行。这使得程序能够更好地利用可用的硬件，加快独立任务的执行速度。

---

3. C 语言的实现

让我们在

C 中创建一个简单的系统：

初始余额为 1000。
一组可以是贷方或借方的交易。
使用线程并行处理这些事务。

3.1.没有针对竞争条件的保护的代码

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

当我们选择具有

多线程处理的环境时，我们所说的竞争条件可能会发生，当两个线程访问并修改相同的值时，我们就会出现竞争条件。出现此问题的原因是，由于调用之间的竞争，无法保证每个线程中访问的值的同步。

多次执行此代码时，最终余额会有所不同，因为线程同时访问和更改余额。

---

3.2.使用互斥体修复

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

互斥体是一种同步原语，可确保一次只有一个线程可以访问共享资源。缩写词互斥体来自英文术语互斥，意思是“互斥”。

当一个线程获取互斥体时，任何其他尝试获取相同互斥体的线程都会被挂起，直到第一个线程释放互斥体。这可以防止两个或多个进程（线程）同时访问共享资源。

4. Rust 中的实现

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
}

将 Rust 视为一种不存在于数据竞赛中的语言并不高效，但我们可以理解 结构 及其编译器如何通过为内存和线程安全带来出色的功能来做出贡献。

Rust 使用 所有权、借用 和并发安全结构等功能，通过编译时保证来对待竞争条件：

• Arc：安全共享不可变数据。
• Mutex 和 RwLock：可变数据的访问控制。

4.1.竞争条件问题

不使用 Arc 和 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.

Rust 不允许在没有保护的情况下从多个线程直接访问可变数据（余额）。
编译器将生成错误，因为余额在没有安全机制的情况下被移动到多个线程（handle1 和 handle2）。
将显示的错误消息是：

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.互斥体和弧的解析

使用 Mutex 和 Arc，我们能够编译并执行我们的代码，并解决了竞争条件问题。

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

4.3.互斥体对比读写锁

Mutex 和 RwLock 用于处理竞争条件，各自具有特定的优点：

互斥体：保证一个线程对资源的独占访问，阻止对其他线程的访问，直到该线程被释放。它简单而有效，但即使是读取也会阻塞资源，从而在读取密集的场景中效率较低。

RwLock：使用 .read() 允许多个同时读取，并使用 .write() 限制独占写入。它非常适合以读取为主的场景，因为它通过允许读取操作中的并行性来提高性能。

---

5. 结论

C 和 Rust 之间的比较突出了解决竞争条件的不同方法。 C 需要注意避免竞争条件错误，而 Rust 除了所有权模型之外还通过 Mutex、RwLock 和 Arc 等工具在编译时降低了这些风险。这不仅使代码更加安全，还通过避免无声错误减少了程序员的心理负担。

总之，Rust 将自己定位为开发竞争系统的绝佳选择，提供安全性和可靠性。

---

6. 参考文献

• 带有代码的仓库：https://github.com/z4nder/rust-data-races
• https://en.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

以上是Rust 线​​程安全性：与 C 的比较。的详细内容。更多信息请关注PHP中文网其他相关文章！