Is what I'm doing even what uWebSockets is designed for?

[DeuSCaNoN]

So I'm just using this personal project of mine to really learn about network scalability but now I'm questioning if it's the right solution.

The simple premise is that users/clients send their "state" 3-5 times a second, and the server averages all the "states" and sends back the average to each client (each client would have some customization to the state though). But I was considering how to write my code assuming there could be thousands of active clients at the same time, so I want my code to be asynchronous.

pApp->ws<PerSocketData>"/post", {
			uWS::SHARED_COMPRESSOR,
			350,
			120,
			64 * 1024,
			true,
			true,
			false,
			0,
			nullptr,
			[this](auto *ws) { /* onOpen*/
				m_postSocketMap[ws->getRemoteAddressAsText()] = ws; // this is a std::map
			},
			[this](auto *ws, std::string_view message, uWS::OpCode opCode) { /* onMessage*/
				// auto data = Utils::ProcessData(message);
				// m_dataAggregater.UpdateData(data, ws->getRemoteAddressAsText());
			},
			nullptr,
			nullptr,
			nullptr,
			[this](auto *ws, int code, std::string_view message) { /* onClose*/
				HandleDisconnectPostClient_(ws->getRemoteAddressAsText());
			}
		}).listen(18080, [](auto *listen_socket) {
				if (listen_socket) {
					std::cout << "Listening on port " << 18080 << std::endl;
				}
		});

The above app works fine, the issue comes from me sending back the message, I learned the hard way that if you try to send data in another thread, crashes will happen.

std::thread[this]()->void // This crashes the server eventually due to an exception thrown during cork
{
	while (true)
	{
		for (auto const& pair : m_postSocketMap)
			// pair.second->send(m_dataAggregater.GetState(pair.first),  uWS::OpCode::TEXT);
		}
		// Sleep for 100 ms
	}
}).detach();

However, I still want to have my message sending not tied to receiving messages from the websocket.

This is when I realize I don't understand how uWebsocket even handles threading. In the above example does every *ws have its own thread? Are all websockets on the same thread? If so how well does the library scale if one app handles thousands of clients?

Is what I'm doing even the right way of using websockets? And if so how should I solve the problem of periodically sending data back to the clients without tying myself to waiting for messages from said clients?

[Jacob-Burckhardt]

However, I still want to have my message sending not tied to receiving messages from the websocket.

This shows one way to do that.

This is when I realize I don't understand how uWebsocket even handles threading. In the above example does every *ws have its own thread?

No. One thread can handle thousands of WebSocket connections.

Are all websockets on the same thread?

They are on as many threads as you create. The documentation says "If you want to, you can simply take the previous example, put it inside of a few std::thread and listen to separate ports, or share the same port (works on Linux)"

[DeuSCaNoN]

Thanks a bunch for the reply, I think I can use that example to send my messages and it really clears that the entire uWS app I have is just on 1 thread handling all the open/close/message events. I don't think I can listen on different ports and I'm on windows but I can deal with improving scaling on that front later.