Question

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.

Answer 1

I am going to suggest a workaround along the lines of well-known self-pipe trick for unblocking select(2) and sidestep the whole messy thread cancellation business.

Since you know the IP address and the port of the socket(7) your thread is blocking on, just sendto(2) some well-known sentinel packet to it from your main thread that would indicate that it’s time to break out of the loop.

This way you don’t have to subvert the std::thread abstraction and can stay reasonably portable.

Edit 0:

If you don’t like workaround, call it a technique 🙂