如何在多线程中正确使用 unique_ptr 进行多态性？ [关闭]

Question

A类是基本类，B是A的继承类，q是unique_ptr(class A)类型的队列。我想从q中获取元素，并为那些继承类调用特殊函数。 这是我的代码：

class A{
public:
    virtual void doSomeWork(){
        std::cout<< "doSomeBasicWork"<<std::endl;
    }
};

class B:public A{
public:
    void doSomeWork(){
        std::cout<< "doSomeSpecificWork"<<std::endl;
    }
};

int main(){
    std::unique_ptr<A> p=std::make_unique<B>();
    std::queue<std::unique_ptr<A>> q;
    q.push(std::move(p));
    auto x=std::move(q.front());
    x->doSomeWork();//print “doSomeSpecificWork”
}

如您所见，在单线程中一切都很好。但是当我在多线程下重写时：

#include <stdio.h>
#include <time.h>
#include <iomanip>
#include <windows.h>
#include<thread>
#include <iostream>
#include <queue>


class A{
public:
    virtual void doSomeWork(){
        std::cout<< "doSomeBasicWork"<<std::endl;
    }
};

class B:public A{
public:
    void doSomeWork(){
        std::cout<< "doSomeSpecificWork"<<std::endl;
    }
};

void producer(std::queue<std::unique_ptr<A>>& q){
        Sleep(1000);
        auto a=std::make_unique<A>();
        q.push(std::move(a));
}

void consumer(std::queue<std::unique_ptr<A>>& q){
        Sleep(1500);
        auto p=std::move(q.front());
        q.pop();
        p->doSomeWork();
}


int main(){
    auto q=std::queue<std::unique_ptr<A>>();
    auto t1=std::thread(consumer,std::ref(q));
    auto t2=std::thread(producer,std::ref(q));
    t1.join();
    t2.join();
}

输出将是 "doSomeBasicWork" ，多态性消失了。 我应该怎么做才能解决这个问题？

Answer 1

正如所指出的，根本原因是一个错字。但是，我强烈怀疑输出将是相同的。这是因为您使用std::make_unique。这将创建一个新实例，但具有基本类型A。你可以阅读here，重要的部分是：

构造一个 T 类型的对象并将其包装在 std::unique_ptr 中。

要解决这个问题，您必须将函数模板化，将具体类型提供给 std::make_unique

类似这样的：

template<class TType>
void producer(std::queue<std::unique_ptr<A>>& q){
        Sleep(1000);
        auto a=std::make_unique<TType>();
        q.push(std::move(a));
}

而且，正如其他人所指出的，您需要使用某种锁定机制，否则您将获得竞争条件。看看here 和here。