pthread_setintrtype() — Set a thread cancelability type

Controls when a cancel request is acted on. The cancelability types can be:

PTHREAD_INTR_ASYNCHRONOUS

The thread can be canceled at any time.

PTHREAD_INTR_CONTROLLED

The thread can be canceled, but only at specific points of execution. These are:

• When waiting on a condition variable, which is pthread_cond_wait() or pthread_cond_timedwait()
• When waiting for the end of another thread, which is pthread_join()
• While waiting for an asynchronous signal, which is sigwait()
• When setting the calling thread's cancelability state, which is pthread_setintr()
• Testing specifically for a cancel request, which is pthread_testintr()
• When suspended because of POSIX functions or one of the following C standard functions: close(), fcntl(), open(), pause(), read(), tcdrain(), tcsetattr(), sigsuspend(), sigwait(), sleep(), wait(), or write()

If unsuccessful, pthread_setintrtype() returns -1 and sets errno to one of the following values:

Error Code

Description

EINVAL

type is an invalid value.

CELEBP50

⁄* CELEBP50 *⁄                                   
#define _OPEN_THREADS                                                           
#include <stdio.h>                                                              
#include <string.h>                                                             
#include <pthread.h>                                                            
#include <errno.h>                                                              
#include <unistd.h>                                                             
                                                                                
int  thstatus;                                                                  
char state[60] = "enable⁄controlled - initial default";                         
                                                                                
void * thfunc(void *voidptr)                                                    
{                                                                               
 int  rc;                                                                       
 char *parmptr;                                                                 
                                                                                
 parmptr = voidptr;                                                             
 printf("parm = %s.\n", parmptr);                                               
 if ( pthread_setintrtype(PTHREAD_INTR_CONTROLLED ) == -1 ) {                   
   printf("set controlled failed. %s\n", strerror(errno));                      
   thstatus = 103;                                                              
   pthread_exit(&thstatus);                                                     
 }                                                                              
 strcpy(state, "disable⁄controlled");                                           
                                                                                
 if ( pthread_setintr(PTHREAD_INTR_ENABLE) == -1 ) {                            
   printf("set enable failed. %s\n", strerror(errno));                          
   thstatus = 104;                                                              
   pthread_exit(&thstatus);                                                     
 }                                                                              
 strcpy(state, "enable⁄controlled");                                            
                                                                                
 strcat(state, " - pthread_testintr");                                          
                                                                                
 while(1) {                                                                     
   pthread_testintr();                                                          
   sleep(1);                                                                    
 }                                                                              
                                                                                
 thstatus = 100;                                                                
 pthread_exit(&thstatus);                                                       
}                                                                               
                                                                                
main(int argc, char *argv[]) {                                                  
  int            rc;                                                            
  pthread_attr_t attrarea;                                                      
  pthread_t      thid;                                                          
  char           parm[] = "abcdefghijklmnopqrstuvwxyz";                         
  int            *statptr;                                                      
                                                                                
  if ( pthread_attr_init(&attrarea) == -1 ) {                                   
    printf("pthread_attr_init failed. %s\n", strerror(errno));                  
    exit(1);                                                                    
  }                                                                             
                                                                                
  if ( pthread_create(&thid, &attrarea, thfunc, (void *)&parm) == -1) {         
    printf("pthread_create failed. %s\n", strerror(errno));                     
    exit(2);                                                                    
  }                                                                             
                                                                                
  sleep(5);                                                                     
                                                                                
  if ( pthread_cancel(thid) == -1 ) {                                           
    printf("pthread_cancel failed. %s\n", strerror(errno));                     
    exit(3);                                                                    
  }                                                                             
                                                                                
   if ( pthread_join(thid, (void **)&statptr)== -1 ) {                          
    printf("pthread_join failed. %s\n", strerror(errno));                       
    exit(4);                                                                    
  }                                                                             
                                                                                
  if ( statptr == (int *)-1 )                                                   
    printf("thread was cancelled. state = %s.\n", state);                       
  else                                                                          
    printf("thread was not cancelled. thstatus = %d.\n", *statptr);             
                                                                                
  exit(0);                                                                      
                                                                                
}                                                                               

Output:

parm = abcdefghijklmnopqrstuvwxyz.
thread was canceled. state = enable/controlled - pthread_testintr.