On 15/Mar - 05:32, rhapsodyn wrote:

here‘s the code

server： class tcp_server { public: tcp_server(boost::asio::io_service& io_service) : acceptor_(io_service),limit(0) { tcp::endpoint endpoint(tcp::v4(), 10000); acceptor_.open(endpoint.protocol()); acceptor_.bind(endpoint); acceptor_.listen(1); start_accept(); }

private: void start_accept() { while(1) { if(limit < 1) break; }

tcp::socket* socket = new tcp::socket(acceptor_.io_service()); acceptor_.async_accept(*socket, boost::bind( &tcp_server::handle_accept, this, socket, boost::asio::placeholders::error)); }

void handle_accept(tcp::socket* s, const boost::system::error_code& error) { if (!error) { ++limit; start_accept(); } }

tcp::acceptor acceptor_;

int limit; };

client： int main(int argc, char* argv[]) { int i = 0; try { boost::asio::io_service io_service;

tcp::resolver resolver(io_service); tcp::resolver::query query("127.0.0.1", "10000"); tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); tcp::endpoint endpoint = *endpoint_iterator;

tcp::socket socket(io_service); socket.connect(endpoint);

while(1) {} } catch (std::exception& e) { std::cerr << e.what() << std::endl; }

return 0; }

I thought i can only launch 1 client, but fact is: i can start two clients and the 3rd one just cerr the what(), what happend there? Is there some better way to get & limit the "living-connection" of the server?

I'm not 100% sure but : - the first one is accepted, as expected - the second one is queued, in the listen queue (size of queue = 1) - the third one is discarded, as the queue is full, and the system returns a ECONNREFUSED However, you only have "active client" at any time. Moreover, the current implementation is really bad. Your active wait completely blocks the asynchronous queue, defeating the purpose of the asynchronous implementation. If you don't want to accept anymore connection, don't call start_accept() if (limit > threshold). Regards, -- Arnaud Degroote PhD Student RIA LAAS / CNRS