C++ objects and threads - c++

Question

I am doing a simple server apllication, where you can have multiple connections, each connection is a single thread. This is the example I would like it to look like(it doesn't work), there is a collection of threads where each thread instantiates an object of the class connection:
class connection{};
class server{
std::vector<std::thread> active_connections;
public:
void listen() {active_connections.push_back(std::thread(connection));}
};
I have been searching for the solution, but the best I could find were some member function threads. The solution turned quite wrong when I tested it, for example:
class connection{};
class server{
std::vector<std::thread> active_connections;
public:
void new_connection() { ... }
void listen() {
active_connections.push_back(std::thread(&server::new_connection,this)); }
};
The message was: error: use of deleted function ‘std::thread::thread(const std::thread&).
Does that mean the std::thread class wants to copy the server class?? I don't know C++ that much so please don't flame, I'm only asking.
Thanks!
EDIT:
This is where this happens:
void server::do_listen()
{
int addr_size = sizeof(sockaddr_in);
sockaddr_in client_sock;
connection_info cn_info;
while(true)
{
int csock;
if((csock = accept(server_sock, (sockaddr*)&client_sock, (socklen_t*)&addr_size)) != -1)
{
printf("Incomming connection from %s.\n", inet_ntoa(client_sock.sin_addr));
memset(&cn_info,0, sizeof(connection_info));
cn_info.sock_addr = client_sock;
cn_info.sock = csock;
std::thread thr(&server::new_connection, *this, cn_info);
thr.join();
}
}
}
This is by far. The server::new_connection() is still empty.

Answer 1

The problem is here:
std::thread thr(&server::new_connection, *this, cn_info);
^
You're binding a copy of the server object; which isn't copyable because it contains (a container of) non-copyable thread objects. Instead, bind a pointer:
std::thread thr(&server::new_connection, this, cn_info);
Some might find a lambda more readable; this captures the this pointer and cn_info by value:
std::thread thr([=]{new_connection(cn_info);});
As a commentor mentions, you could obfuscate the solution by binding a reference wrapper:
std::thread thr(&server::new_connection, std::ref(*this), cn_info);
but I prefer to remove, rather than add, complexity where possible.

Answer 2

Does that mean the std::thread class wants to copy the server class?
No, that means a copy of a std::thread is made somewhere, but that's forbidden as std::thread in NonCopyable (note the thread(const thread&) = delete; in the list of constructors).
You should eliminate any code that performs a copy of a thread. The one you've posted doesn't perform such copy.
An example where a copy is made "behind the scene" would be a push_back in a vector of a thread variable, i.e.:
std::thread myThread;
myVector.push_back(myThread);
In your code:
active_connections.push_back(std::thread(&server::new_connection,this));
as you're pushing back a temporary, it doesn't get copied but moved into the vector.

Answer 3

More a design question to you author:
You create one thread for one connection. If you have ten connections you have ten threads. But what do you do if you have 10000 connections you want to handle? I'm not sure your operating system likes that.
A much better connection handling approach - only in my opinion - would be if you only have N threads that handle your network connections. If your computer has e.g. six cores you could spend one, two or more threads only for the network stuff. So you have a thread pool of a certain size for this.
The proactor pattern could be interesting for you:
http://en.wikipedia.org/wiki/Proactor_pattern
If you're looking for a library that could handle such things, you could look to the upcoming C++ Boost library named Boost.Asynchronous:
https://github.com/henry-ch/asynchronous
This library is still in development, but really good. I've made some simple client/server applications with the library.