在Rust中的线程之间共享可变数据
在Rust中，线程之间共享可变数据可以通过使用互斥锁（Mutex）或原子类型（Atomic Types）来实现。互斥锁是一种同步原语，用于确保在任意时刻只有一个线程可以访问共享数据。原子类型则提供了一种无锁的方式来进行并发访问，保证了操作的原子性。
使用互斥锁时，可以使用标准库中的std::sync::Mutex来创建一个互斥锁对象。互斥锁使用了内部可变性（interior mutability）的概念，允许在不可变引用的同时，通过获取锁来修改数据。以下是一个示例代码：
use std::sync::Mutex;
fn main() {
// 创建一个互斥锁
let mutex = Mutex::new(0);
// 在多个线程中共享可变数据
for _ in 0..10 {
let mutex_clone = mutex.clone();
std::thread::spawn(move || {
// 获取锁
let mut data = mutex_clone.lock().unwrap();
// 修改数据
*data += 1;
});
}
// 等待所有线程执行完毕
std::thread::sleep(std::time::Duration::from_secs(1));
// 输出最终结果
println!("Data: {:?}", mutex.lock().unwrap());
}在上述代码中，我们创建了一个互斥锁mutex，然后在多个线程中共享可变数据data。每个线程通过调用lock方法获取锁，并在获取到锁之后修改数据。最后，我们等待所有线程执行完毕，并输出最终结果。
除了互斥锁，Rust还提供了一些原子类型，如std::sync::atomic::AtomicBool、std::sync::atomic::AtomicI32等。这些类型可以直接在多个线程之间共享，并保证操作的原子性，无需使用互斥锁。使用原子类型可以提高性能，但需要注意原子类型的使用场景和限制。
总结起来，在Rust中，线程之间共享可变数据可以通过互斥锁或原子类型来实现。互斥锁适用于需要在任意时刻只有一个线程访问共享数据的场景，而原子类型适用于无需互斥锁的并发访问场景。具体选择哪种方式取决于具体的需求和性能要求。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 云原生应用引擎（TKE）：https://cloud.tencent.com/product/tke
- 云数据库 MySQL 版（CMYSQL）：https://cloud.tencent.com/product/cmysql
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 人工智能（AI）：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 移动开发（移动推送、移动分析）：https://cloud.tencent.com/product/mobile
- 区块链（BCS）：https://cloud.tencent.com/product/bcs
- 元宇宙（Metaverse）：https://cloud.tencent.com/solution/metaverse
相关·内容
1回答
读取受互斥锁保护的共享数据而不锁定互斥锁
c++、thread-safety、locking、mutex、atomic
给定受互斥锁保护的共享数据。在不需要锁定互斥锁的情况下读取部分共享数据的合适方法是什么？如下例所示，使用std::atomic_ref是否是合适的方式？ struct A
{
std::mutex mutex;
int counter = 0;
void modify()
{
std::lock_guard<std::mutex> guard(mutex);
// do something with counter
}
int getCounter()
{
return std::atomic_ref<int>(co
浏览 18提问于2021-01-13得票数 0
1回答
如何实现std：：原子
c++、multithreading、mutex、lock-free、stdatomic
我正在研究mutex和atomic在C++11中的区别。
据我理解，mutex是一种基于OS/内核的锁机制。例如，Linux提供了一种机制，即futex。借助futex，我们可以实现mutex和semaphore。此外，我知道futex是由低级原子操作(如CompareAndSet、CompareAndSwap )实现的。
对于std::atomic，我知道它是基于C++11引入的内存模型实现的，但是，我不知道内存模型是如何在底层实现的。如果它也是由原子操作(如CompareAndSet )实现的，那么std::atomic和mutex之间有什么区别？
总之，如果std::atomic::is
浏览 2提问于2019-12-04得票数 9
回答已采纳
2回答
C++中的互斥物与锈病中的std::sync::Mutex
c++11、rust、concurrency、deadlock、borrow-checker
我一直发现std::mutex是C++，它是手动的，容易出错。我需要手动将某个std::mutex属性指定为特定变量，并且我需要记住在访问这些特定变量之前始终锁定std::mutex。
然后我开始学习Rust，我在Rust中看到，std::sync::Mutex是对象的包装器，类似于C++中的std::tuple是对象的包装器。同步：：Mutex可以被锁定，然后它返回一个对象来访问成员。只要该句柄对象存在，std::sync::Mutex就会被锁定，并在析构函数中解锁(或者其他什么，不确定它在Rust中是如何工作的)。我的第一印象是，这是一个更好的方式，把互斥物与它应该保护的数据！
所以我的想
浏览 11提问于2022-01-29得票数 1
1回答
为什么condition_variable在等待生产者-消费者的锁定？C++
c++、c++11、concurrency、locking、producer-consumer
请参阅下列经典生产者-消费者代码：
int main()
{
std::queue<int> produced_nums;
std::mutex m;
std::condition_variable cond_var;
bool done = false;
bool notified = false;
std::thread producer([&]() {
for (int i = 0; i < 5; ++i) {
std::this_thread::sleep_for(std
浏览 0提问于2018-05-21得票数 6
回答已采纳
2回答
避免并发等待对象中的死锁
c++、c++14、mutex、condition-variable、stdatomic
我实现了一个“票证”类，它作为多个线程之间的shared_ptr共享。
程序流如下所示：
调用parallelQuery()来启动新的查询作业。创建了票据的共享实例。
查询被分成多个任务，每个任务都在一个工作线程上排队(这个部分很重要，否则我只会加入线程并完成)。每个任务都获得共享票证。
调用ticket.wait()以等待作业的所有任务完成。
当完成一项任务时，它会调用票据上的done()方法。
当完成所有任务时，票证被解锁，来自任务的结果数据聚合并从parallelQuery()返回。
在伪码中：
std::vector<T> parall
浏览 0提问于2019-08-10得票数 0
回答已采纳
2回答
为什么std::mutex比std::atomic快？
c++、mutex、atomic
我想以多线程模式将对象放入std::vector中。因此，我决定比较两种方法:一种使用std::atomic，另一种使用std::mutex。我看到第二种方法比第一种方法更快。为什么？
我使用的是GCC 4.8.1，在我的机器上(8个线程)，我看到第一个解决方案需要391502微秒，第二个解决方案需要175689微秒。
#include <vector>
#include <omp.h>
#include <atomic>
#include <mutex>
#include <iostream>
#include <chrono
浏览 0提问于2015-04-09得票数 16
回答已采纳
1回答
“M&M规则”是否适用于std：：原子数据成员？
c++、c++11、c++14、atomic、mutable
“可变的用于指定成员不影响类的外部可见状态(通常用于互斥对象__、备注缓存、延迟评估和访问检测)。”。
这句话让我纳闷：
指导方针:记住“M&M规则”：用于成员变量、可变变量和互斥(或原子)，__。[参考: GotW #6a解决方案:Const-正确性，第1部分(更新为C ++11/14)]()
我理解为什么“M&M规则”适用于const-functions数据成员:允许std::mutex在锁定/解锁互斥数据成员的同时实现线程安全，但是“M&M规则”也适用于std::atomic数据成员吗？
浏览 4提问于2022-03-28得票数 1
回答已采纳
3回答
在atomic<bool>中使用std::condition_variable
c++、multithreading、c++11
有几个关于原子的问题，还有一些关于std::condition_variable的问题。但是我的问题是，我下面的用法是否正确？
三个线程，一个ctrl线程在取消暂停其他两个线程之前执行准备工作。当工作线程(发送者/接收者)处于其紧密的发送/接收循环中时，CTRL线程还能够暂停它们。使用原子的想法是为了在没有设置用于暂停的布尔值的情况下使紧密循环更快。
class SomeClass
{
public:
//...
浏览 0提问于2016-03-21得票数 16
回答已采纳
4回答
std::condition_variable的布尔谓词在C++中应该是易失性的吗？
c++、multithreading、c++11、undefined-behavior、c++-standard-library
我听到了很多相互矛盾的回答，现在我不知道该怎么想了。一致同意的知识是，为了在C++中以线程安全的方式共享内存，需要使用易失性和 std::mutex。
基于这种理解，我一直在编写这样的代码：
volatile bool ready = false;
std::condition_variable cv;
std::mutex mtx;
std::unique_lock<std::mutex> lckr{ mtx };
cv.wait(lckr, [&ready]() -> bool { return ready; });
但后来我在CppCon看了一堂关于钱德勒·卡鲁
浏览 9提问于2022-01-27得票数 4
2回答
std::atomic<bool>与std::mutex结合使用的正确性
c++、multithreading、c++11、stdatomic、stdmutex
我已经编写了一个共享优先级队列类。
为了发出停止提供数据的信号，我使用了Cancel()方法，该方法将符号done设置为false，并且不允许应用程序从队列中写入/读取任何数据。我不确定是否要将std::atomic<bool>与std::mutex和std::condition_variable结合使用。我不确定我的解决方案是否是线程安全的，或者是否会发生竞争条件：
Enqueue方法的原始版本是：
std::deque<T> deque;
std::mutex mtx;
std::condition_variable cv;
std::atomic<bool&
浏览 76提问于2017-06-07得票数 0
1回答
C++我们可以对琐碎的用户定义的数据类型使用什么原子操作
c++11、c++14
我试图理解std：：原子类型和原子操作。下面是我的代码：
#include <atomic>
#include <iostream>
class A
{
public:
int x;
void Show() {}
};
int main()
{
std::atomic<A> fooA;
// fooA.Show(); -- gives me std::atomic<A> has no member Show()
}
当我们定义一个用户类型(如Mtype.load()等)时，我们可以做哪些原子操作?我们如何使用带
浏览 3提问于2020-09-01得票数 1
回答已采纳
因此，我试图在一个特征中定义一个方法，它将产生一个线程并利用另一个特征方法，但我有点纠结于如何从Arc<...>中“解压”它： use std::sync::Arc;
use std::sync::Mutex;
use websocket::{Message, WebSocketResult};
trait Sender<S>
where
S: Into<Message<'static>> + Send,
{
fn send_once(&mut self, message: S) -> WebSocke
浏览 23提问于2021-11-13得票数 0
回答已采纳
1回答
使用不同的gcc优化来C++不同的错误
c++、multithreading、gcc
使用不同的gcc优化，我的程序死于不同的操作系统信号，我想知道原因是否相同。
在使用O2编译的c++多线程程序中，由于abort()，我得到了一个核心转储。
Program terminated with signal 6, Aborted.
#0 0x00007ff2572d28a5 in raise () from /lib64/libc.so.6
我只是不能找出哪个是原因，因为它似乎是在本地std::vector析构函数中。这对我来说毫无意义。
(gdb) thread 1
[Switching to thread 1 (Thread 0x7ff248d6c700 (LWP 16767
浏览 2提问于2014-09-01得票数 1
2回答
在修改过程中，通知线程总是需要锁定共享数据吗？
c++、multithreading、c++11、mutex、condition-variable
当使用条件变量时，将线程的典型步骤描述为：
获取std::mutex (通常通过std::lock_guard)
在持有锁时执行修改。
在notify_one或notify_all上执行std::condition_variable (不需要保存锁以进行通知)
对于下面所示的简单情况，主线程在修改它时是否需要锁定“停止”？虽然我理解修改共享数据时的锁定几乎总是一个好主意，但我不知道为什么在这种情况下需要锁。
std::condition_variable cv;
std::mutex mutex;
bool stop = false;
void worker()
浏览 3提问于2017-11-17得票数 2
回答已采纳
1回答
使用条件变量而不是lock_guard
c++、multithreading、condition-variable
我有一个简单的程序，其中我想输出数字1-100，其中一个线程输出所有奇数，另一个线程输出所有偶数。使用lock_guard，这是一个相当容易的任务。守则如下：
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <thread>
std::mutex m;
void print_numbers(int i)
{
for (i; i <= 100; i++)
{
std::lock_guard<
浏览 0提问于2015-07-07得票数 0
回答已采纳
1回答
是什么让boost::shared_mutex这么慢？
c++、boost、boost-thread
我使用谷歌基准运行以下3个测试，结果令我惊讶，因为RW锁在发布模式下比简单互斥锁慢了4倍。(在调试模式下比简单互斥慢10倍)
void raw_access() {
(void) (gp->a + gp->b);
}
void mutex_access() {
std::lock_guard<std::mutex> guard(g_mutex);
(void) (gp->a + gp->b);
}
void rw_mutex_access() {
boost::shared_lock<boost::shared_mu
浏览 3提问于2019-06-26得票数 3
回答已采纳
1回答
c++11 atomic<int>++比std::mutex受保护的int++慢得多，为什么？
c++、performance、c++11、mutex、atomic
为了比较std::atomic<int>++和std::mutex受保护的int++之间的性能差异，我有以下测试程序：
#include <iostream>
#include <atomic>
#include <mutex>
#include <thread>
#include <chrono>
#include <limits>
using namespace std;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<std::int32_t&g
浏览 4提问于2022-09-24得票数 2
回答已采纳
3回答
VC++：当线程比cpus多但g++下没有线程时性能下降
c++、multithreading、visual-c++、c++11、visual-studio-2013
简单的多线程c++11程序，其中所有线程锁定相同的互斥锁紧循环。
当它使用8个线程(作为逻辑cpus的数量)时，它可以达到500万个锁/秒。
但是，只添加一个额外的线程-性能下降到200,000/秒！
编辑：
to g++4.8.2 (ubuntu x64)：即使有100个线程！(性能是性能的两倍以上，但这是另一个故事)-，所以这确实是VC++互斥实现特有的一个问题。
我用以下代码(Windows7 X64)复制了它：
#include <chrono>
#include <thread>
#include <memory>
#include <mu
浏览 1提问于2014-01-21得票数 9
2回答
使用栅栏确保其他线程的数据更新可见性
multithreading、c++11、synchronization、memory-fences
我有两个问题-考虑两个线程，一个对共享数据进行更改，另一个对共享数据进行操作。这两个线程在对数据进行任何操作之前都会获取一个互斥锁。
如何保证对数据进行操作的线程总是能看到第一线程所做的更改？是否需要一组获取/释放屏障，或者线程是否通过使用互斥来隐式同步？如果我不使用互斥锁(但要确保独占访问)怎么办？
还有:栅栏是否真的在没有交错/后续原子操作的情况下执行任何操作(例如，在atomic_bool中存储标志，发出“就绪”信号等)？
下面是一个用例：
void func()
{
std::atomic_bool quit = false;
std::vector<float
浏览 1提问于2015-11-16得票数 0
1回答
std::shared_mutex不使用执行lock_shared()的线程进行缩放
c++、multithreading
我编写了一个简单的程序来测试std::shared_mutex的性能，通过很多线程循环lock_shared()。但是从结果来看，似乎没有增加更多的线程，这对我来说是没有意义的。
您可能会说，这是因为stopFlag 限制了性能，所以第二个循环一个增加本地计数器的测试，这几乎是在初始中的完美缩放。
注释中的结果是使用带有MSVC标志的Release编译的。
int main()
{
const auto threadLimit = std::thread::hardware_concurrency() - 1; //for running main()
struct Shar
浏览 2提问于2020-06-23得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
