C++ 多线程报错访问冲突

hellomyprogram

我在尝试做一个生产者+消费者多线程模型的时候，在进行调试时，出现报错：
0xC0000005: 读取位置 0x0000000000000070 时发生访问冲突。
以下是我的源代码（生产者部分被略去）：

1. export module core.thread;
   
2. import std;
   
3. import core.constants;
   
4. 
   
5. using function = std::function<void()>;
   
6. using lock = std::lock_guard<std::mutex>;
   
7. 
   
8. export namespace thread
   
9. {
   
10.         class Group
    
11.         {
    
12.                 protected:
    
13.                 std::queue<function> queue;
    
14.                 public:
    
15.                 std::condition_variable variable;
    
16.                 std::mutex mutex;
    
17.                 Group() = default;
    
18.                 Group(const Group&) = delete;
    
19.                 Group(Group&&) = delete;
    
20.                 std::optional<function> get_task() noexcept
    
21.                 {
    
22.                         lock lock(this->mutex);
    
23.                         if (this->queue.empty())
    
24.                         {
    
25.                                 return std::nullopt;
    
26.                         };
    
27.                         function task = this->queue.front();
    
28.                         this->queue.pop();
    
29.                         return task;
    
30.                 };
    
31.                 void add_task(function task) noexcept
    
32.                 {
    
33.                         lock lock(this->mutex);
    
34.                         this->queue.push(task);
    
35.                         this->variable.notify_one();
    
36.                 };
    
37.         };
    
38. 
    
39.         class BasicThread
    
40.         {
    
41.                 protected:
    
42.                         std::thread thread;
    
43.                         choice::status status;
    
44.                         std::string name;
    
45.                 public:
    
46.                         BasicThread() = delete;
    
47.                         BasicThread(const BasicThread&) = delete;
    
48.                         BasicThread(BasicThread&&) = default;
    
49.                         BasicThread(const std::string& name) :
    
50.                                 name(name)
    
51.                         {
    
52.                                 this->thread = std::thread(&BasicThread::run, this);
    
53.                         };
    
54.                         virtual void run() {};
    
55.                         inline void join() noexcept
    
56.                         {
    
57.                                 if (this->thread.joinable())
    
58.                                 {
    
59.                                         this->thread.join();
    
60.                                 };
    
61.                         };
    
62.         };
    
63. 
    
64.         class Worker : public BasicThread
    
65.         {
    
66.                 protected:
    
67.                         std::shared_ptr<Group> group;
    
68.                 public:
    
69.                         Worker() = delete;
    
70.                         Worker(const Worker&) = delete;
    
71.                         Worker(Worker&&) = default;
    
72.                         Worker(const std::string& name, const std::shared_ptr<Group>& group) :
    
73.                                 BasicThread(name),
    
74.                                 group(group) {};
    
75.                         void run()
    
76.                         {
    
77.                                 std::optional<function> current_task;
    
78.                                 while (this->status != choice::status::terminating)
    
79.                                 {
    
80.                                         std::unique_lock<std::mutex> lock{ this->group->mutex };
    
81.                                         this->group->variable.wait(lock, [&current_task, this]() {return current_task = this->group->get_task(); }); // Only runs if a new task is available
    
82.                                         lock.unlock();
    
83.                                         current_task.value()();
    
84.                                 };
    
85.                         };
    
86.                         inline void attach(const std::shared_ptr<Group>& group) noexcept
    
87.                         {
    
88.                                 this->group = group;
    
89.                         };
    
90.         };
    
91. };

复制代码

这是我的调试部分：

1. import core.thread;
   
2. import std;
   
3. 
   
4. int main()
   
5. {
   
6.         std::shared_ptr<thread::Group> group;
   
7.         thread::Worker worker{ "test", group };
   
8.         return 0;
   
9. };

复制代码

FishC

你好！你的代码中存在一些问题导致了访问冲突的报错。首先，你在主函数中定义了一个名为`group`的`std::shared_ptr`智能指针，但没有初始化它，所以会导致未定义的行为。你需要为`group`分配内存并初始化它，可以使用`std::make_shared`函数来实现：

1. std::shared_ptr<thread::Group> group = std::make_shared<thread::Group>();

复制代码

其次，在`Worker`类的构造函数中，你将`std::shared_ptr`对象传递给了`group`成员，但是在声明`group`时，没有指定它指向的具体类型，这也是引起编译错误的原因。你需要明确指出`group`指向的是`thread::Group`类型：

1. std::shared_ptr<thread::Group> group;

复制代码

但是请注意，这只是修复了编译错误，而不是解决访问冲突的问题。要解决访问冲突，你还需要对多线程间的共享资源进行正确的加锁处理。在你的代码中，生产者通过添加任务到队列中来共享资源，消费者通过从队列中获取任务来共享资源。

你可以在生产者添加任务时加锁，以及在消费者获取任务时加锁：

1. // 生产者
   
2. void add_task(function task) noexcept
   
3. {
   
4.     lock lock(this->mutex);
   
5.     this->queue.push(task);
   
6.     this->variable.notify_one();
   
7. };
   
8. 
   
9. // 消费者
   
10. void run()
    
11. {
    
12.     std::optional<function> current_task;
    
13.     while (this->status != choice::status::terminating)
    
14.     {
    
15.         std::unique_lock<std::mutex> lock(this->group->mutex);
    
16.         this->group->variable.wait(lock, [this]() { return !this->group->queue.empty(); }); // 只有当队列非空时才继续执行
    
17.         current_task = this->group->get_task();
    
18.         lock.unlock();
    
19.         if (current_task.has_value())
    
20.         {
    
21.             current_task.value()();
    
22.         }
    
23.     }
    
24. }

复制代码

这样做的目的是保证在生产者和消费者之间正确地同步资源访问。通过加锁，确保只有一个线程能够同时对资源进行访问，避免访问冲突的问题。

希望以上解答能够帮助到你！如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。