I'm using a C++11 std::thread. Its main loop consists of a blocking recvfrom() call which listens for UDP packets arriving on a DATAGRAM socket, and some sophisticated code that parses the message and manipulates loads of STL containers in the process.
The thread belongs to a class (helloexchange), is started by the constructor and should be cancelled in the destructor.
For obvious reasons, I do not want to forcefully terminate the thread, since this could currupt the data structures, which are partially located outside the class.
When using pthread instead of std::thread, there is the pthread_cancel method, which, in conjunction with pthread_setcancelstate, provides all the functionality I require: It will only cancel the thread while it's blocking in certain system calls, and the cancelling can be completely disabled for certain sections. The cancel is then performed once it's enabled again.
This is a complete example of working pthread code:
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>
#include <sys/socket.h>
#include <sys/types.h>
#include <cstdio>
#include <pthread.h>
#include <net/if.h>
#include <ifaddrs.h>
int sock;
void *tfun(void *arg) {
std::cout << "Thread running" << std::endl;
while(true) {
char buf[256];
struct sockaddr_in addr;
addr.sin_family = AF_INET;
socklen_t addrlen = sizeof(addr);
//allow cancelling the thread
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
//perform the blocking recvfrom syscall
int size = recvfrom(sock, (void *) buf, sizeof(buf), 0,
(struct sockaddr *) &addr, &addrlen);
//disallow cancelling the thread
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
if(size < 0) {
perror("Could not receive packet");
return NULL;
} else {
//process the packet in the most complex ways
//you could imagine.
std::cout << "Packet received: " << size << " bytes";
std::cout << std::endl;
}
}
return NULL;
}
int main() {
//open datagram socket
sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock < 0) {
perror("Could not open socket");
return 1;
}
//bind socket to port
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(1337);
addr.sin_addr.s_addr = 0;
if(bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Could not bind datagram socket");
return 2;
}
//create the listener thread
pthread_t t;
if(pthread_create(&t, NULL, tfun, NULL) != 0) {
perror("Could not thread");
return 3;
};
//wait
std::cin.get();
//cancel the listener thread. pthread_cancel does not block.
std::cout << "Cancelling thread" << std::endl;
if(pthread_cancel(t) != 0) {
perror("Could not cancel thread");
}
//join (blocks until the thread has actually cancelled).
std::cout << "Joining thread" << std::endl;
if(pthread_join(t, NULL) != 0) {
perror("Could not join thread");
} else {
std::cout << "Join successful" << std::endl;
}
//close socket
if(close(sock) != 0) {
perror("Could not close socket");
};
}
However, std::thread does not support cancel, nor does std::this_thread support setcancelstate (You'll find a reference here). It does, however, support native_handle, which returns the internally used pthread_t id.
The obvious approach of just sending pthread_cancel() to the thread's native handle results in a segmentation fault, though:
#include <iostream>
#include <thread>
#include <cstdio>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <pthread.h>
#include <net/if.h>
#include <ifaddrs.h>
int sock;
void tfun() {
std::cout << "Thread running" << std::endl;
while(true) {
char buf[256];
struct sockaddr_in addr;
addr.sin_family = AF_INET;
socklen_t addrlen = sizeof(addr);
//perform the blocking recvfrom syscall
int size = recvfrom(sock, (void *) buf, sizeof(buf), 0,
(struct sockaddr *) &addr, &addrlen);
if(size < 0) {
perror("Could not receive packet");
return;
} else {
//process the packet in the most complex ways
//you could imagine.
std::cout << "Packet received: " << size << " bytes";
std::cout << std::endl;
}
}
return;
}
int main() {
//open datagram socket
sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock < 0) {
perror("Could not open socket");
return 1;
}
//bind socket to port
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(1337);
addr.sin_addr.s_addr = 0;
if(bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Could not bind datagram socket");
return 2;
}
//the listener thread
std::thread *t = new std::thread(&tfun);
//wait
std::cin.get();
//cancel the listener thread. pthread_cancel does not block.
std::cout << "Cancelling thread" << std::endl;
if(pthread_cancel(t->native_handle()) != 0) {
perror("Could not cancel thread");
}
//join (blocks until the thread has actually cancelled).
std::cout << "Joining thread" << std::endl;
t->join();
delete t;
//close socket
if(close(sock) != 0) {
perror("Could not close socket");
};
}
results in:
(gdb) run
Starting program: /tmp/test/test-dbg
warning: Could not load shared library symbols for linux-vdso.so.1.
Do you need "set solib-search-path" or "set sysroot"?
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/usr/lib/libthread_db.so.1".
[New Thread 0x7ffff6550700 (LWP 11329)]
Thread running
Cancelling thread
Joining thread
Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7ffff6550700 (LWP 11329)]
0x00007ffff6e67b45 in __gnu_cxx::__verbose_terminate_handler() () from /usr/lib/libstdc++.so.6
Is there any way to cancel a std::thread while it's blocking in a syscall?
edit
I'm not asking for a cross-platform solution; a POSIX-conforming solution would suffice.
