C++ Boost:：调用join时线程访问冲突

我在尝试创建多线程服务器时遇到一些问题。在我需要从服务器上删除客户端之前，一切正常

服务器在自己的线程中运行，然后每个客户机也有自己的线程

我对所有线程都使用boost:：thread。当我需要阻止客户时，我会打电话

void StopClient()
{
    assert(mThread);

    mStopMutex.lock();
    mStopRequested = true;
    mStopMutex.unlock();

    shutdown(mSocket,2);

    mThread->join();
}

向行中添加断点

shutdown(mSocket,2);

我可以看到mThread不存在！这是否意味着线程已经退出？对于boost:：thread，是否始终需要调用join（）

如果允许代码运行，则会出现访问冲突错误

更新

服务器线程

void StartServer() 
{
    assert(!mListenThread);
    mListenThread = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&ServerThread::Listen, this)));
    mUpdateThread = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&ServerThread::Update, this)));
}

void StopServer()
{
    assert(mListenThread);
    mStopRequested = true;

            mMutex.lock();
            for(int i = 0; i < mClients.size(); i++ )
                mClients[i]->StopClient();
            mMutex.unlock();

    mListenThread->join();
}

void Listen()
{
    while (!mStopRequested)
    {
        std::cout << "Waiting for connection" << std::endl;         
        if(mClientSocket = accept( mServerSocket, (sockaddr*) &mServerAddr, &addrlen ) )
        {
            mMutex.lock();
            if( mClients.size() > 0 )
            {
                for( int i = 0; i < mClients.size(); i++ )
                {
                    if( mClients[i]->getClientSocket() != mClientSocket )
                    {
                        ClientThread newClient;
                        newClient.Initialise(mClientSocket);
                        mClients.push_back(&newClient);
                        mClients[mClients.size()-1]->StartClient();
                        break;
                    }
                }
            }
            else
            {
                ClientThread newClient;
                newClient.Initialise(mClientSocket);
                mClients.push_back(&newClient);
                mClients[mClients.size()-1]->StartClient();
            }
            mMutex.unlock();
        }
    }
}          

void Update()
{
    while (!mStopRequested)
    {
        mMutex.lock();

        std::cout << "::::Server is updating!::::" << mClients.size() << std::endl;
        for( int i = 0; i< mClients.size(); i++ )
        {
            if( !mClients[i]->IsActive() )
            {
                mClients[i]->StopClient();
                mClients.erase( mClients.begin() + i );
            }
        }

        mMutex.unlock();

    }
}

void StartServer（）
{
断言（！mListenThread）；
mListenThread=boost:：shared_ptr（新的boost:：thread（boost:：bind（&ServerThread:：Listen，this））；
mUpdateThread=boost:：shared_ptr（新的boost:：thread（boost:：bind（&ServerThread:：Update，this））；
}
void StopServer（）
{
断言（mListenThread）；
mStopRequested=true；
mMutex.lock（）；
对于（int i=0；iStopClient（）；
mMutex.unlock（）；
mListenThread->join（）；
}
void Listen（）
{
而（！mStopRequested）
{
std:：cout getClientSocket（）！=mClientSocket）
{
clientthreadnewclient；
新建客户端。初始化（mClientSocket）；
mClients.push_back（&newClient）；
mClients[mClients.size（）-1]->StartClient（）；
打破
}
}
}
其他的
{
clientthreadnewclient；
新建客户端。初始化（mClientSocket）；
mClients.push_back（&newClient）；
mClients[mClients.size（）-1]->StartClient（）；
}
mMutex.unlock（）；
}
}
}          
无效更新（）
{
而（！mStopRequested）
{
mMutex.lock（）；
std:：cout这里没有足够的代码来确定到底发生了什么，但这里有一些东西需要检查：


您的客户端线程中可能有一个正在检查mStopRequested成员的处理循环。在处理循环退出之前，它是否正在更改mThread成员
当您获得访问冲突时，mThread是否为NULL？或者，它是否是其他值？在将mStopRequested设置为true之前它是否有效
这里没有足够的代码来确定到底发生了什么，但这里有一些东西需要检查：


您的客户端线程中可能有一个正在检查mStopRequested成员的处理循环。在处理循环退出之前，它是否正在更改mThread成员
当您获得访问冲突时，mThread是否为NULL？或者，它是否是其他值？在将mStopRequested设置为true之前它是否有效

这将在堆栈上创建一个局部变量，并将其地址放入您的mclient列表中。然后范围结束，局部变量也结束。这将使您的列表
mclient
指向不再存在的内容

这将在堆栈上创建一个局部变量，并将其地址放入您的mclient列表中。然后作用域结束，局部变量也结束。这将使您的列表
mclient
指向不再存在的内容。
您需要向我们显示更多的代码。
mThread
设置在哪里，设置为什么值？它还被用在哪里？你说“mThread不存在”是什么意思？它是空的还是指向一个已删除的对象？谢谢你的回复。我已经更新以显示更多的代码！@Rüdiger它只是指向一个已删除的对象。你需要向我们显示更多的代码。在哪里设置了
mThread
以及设置了什么值？在哪里使用了它？你说“mThread不存在”是什么意思？它是空的还是指向一个已删除的对象？谢谢你的回复。我已经更新以显示更多的代码！@Rüdiger它只是指向一个已删除的对象。这是一个很好的观点！我已经将代码更改为
ClientThread*newClient=newclientthread（）；newClient->Initialise（mClientSocket）；mClients.push_back（newClient）
现在可以工作了！：）谢谢！这是一个很好的观点！我已经将代码更改为
ClientThread*newClient=newclientthread（）；newClient->初始化（mClientSocket）；mClients.push_back（newClient）；
现在可以工作了！：）谢谢！
void StartClient()
{
    assert(!mThread);
    mThread = boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&ClientThread::Update, this)));
}

void Update()
{
    bool stopRequested;
    do
    {
        mStopMutex.lock();
        stopRequested = mStopRequested;
        mStopMutex.unlock();

        std::cout << "lol" << std::endl;
        if( mTimeOut < 1000 )
        {
            mTimeOut++;
        }
        else
        {
            mActive = false;
        }

        boost::this_thread::interruption_point();
    }
    while( !stopRequested);
}

            ClientThread newClient;
            newClient.Initialise(mClientSocket);
            mClients.push_back(&newClient);