It's crashed even close the listen socket by loop::defer

[pengweichu]

In fact, I read all user manual, and all other related issues, below are my minimal code, you can see I closed the listen socket by loop::defer, but still got the same crash, just run it, no need to open the browser to connect, I'm using master branch with libuv 1.4.0.

#include "App.h"
#include <thread>
#include <memory>
#include <chrono>
#include <deque>
#include <unordered_map>
#include <shared_mutex>
#include <mutex>
#include <cstdint>

class WebSocketPublisher
{
public:

    // None SSL
    using WebSocketClient = uWS::WebSocket<false, true>; // 1st: SSL, 2nd: server
 //   using WebSocketClient = uWS::WebSocket<true, true>;

    struct PerSocketData
    {
        uint64_t id = 0;
    };


    WebSocketPublisher()
        : mLoop(nullptr)
        , mListenSocket(nullptr)
        , mShutdown(true)
    {

    }
    ~WebSocketPublisher()
    {
    }

    bool run()
    {
        if (!mShutdown)
        {
            return false;
        }

        mThread = std::make_shared<std::thread>([this]()
            {
                this->threadLoop();
            });

        return true;
    }

    void shutdown()
    {
        if (mThread && !mShutdown)
        {
            mLoop->defer([this]()
                {
                    us_listen_socket_close(0, this->mListenSocket);
                });


            mShutdown = true;
            mThread->join();
        }
    }


private:

    void threadLoop()
    {
        mLoop = uWS::Loop::get();
        mApp = std::make_shared<uWS::App>();
        mShutdown = false;

        mApp->ws<PerSocketData>("/*",
            {
                /* Settings */
                .compression = uWS::SHARED_COMPRESSOR,
                .maxPayloadLength = 16 * 1024 * 1024,
                .idleTimeout = 0,
                .maxBackpressure = 1 * 1024 * 1204,
                .open = [this](auto* ws)
                {

                },
                  .message = [this](auto* ws, std::string_view message, uWS::OpCode opCode)
                  {
                  },
                    .drain = [](auto* ws)
                    {
                      /* Check getBufferedAmount here */
                  },
                    .ping = [](auto* ws)
                    {

                    },
                    .pong = [](auto* ws)
                    {

                    },
                    .close = [this](auto* ws, int code, std::string_view message)
                    {
                        std::cout << "closed" << std::endl;
                        auto data = static_cast<PerSocketData*>(ws->getUserData());
                        if (data)
                        {

                        }

                        ws->close();

                        /* We automatically unsubscribe from any topic here */
                    }
            }).listen(9001, [this](auto* token)
                {
                    mListenSocket = token;
                    if (mListenSocket)
                    {
                        std::cout << "Thread " << std::this_thread::get_id() << " listening on port " << 9001 << std::endl;
                    }
                    else
                    {
                        std::cout << "Thread " << std::this_thread::get_id() << " failed to listen on port " << 9001 << std::endl;
                    }
                }).run();

                std::cout << "Thread is shutdown..." << std::endl;
    }

private:
    struct uWS::Loop* mLoop;
    struct us_listen_socket_t* mListenSocket;
    bool mShutdown;
    std::shared_ptr<std::thread> mThread;
    std::shared_ptr<uWS::App> mApp;
};



int main()
{
    WebSocketPublisher webPublisher;
    webPublisher.run();

    std::this_thread::sleep_for(std::chrono::seconds(5));

    std::cout << "Start to shutdown" << std::endl;

    webPublisher.shutdown();

    std::this_thread::sleep_for(std::chrono::seconds(5));

    std::cout << "Exit...." << std::endl;

    return 0;
}

[ghost]

You are not destructing things in defined order. You have to destroy the App before the Loop because the App refers the Loop. Your example has an undefined order of destruction.