make pthread exit within fixed time

Question

Here is my situation

global var n;
global var result;
void* solve_for_n(void *arguments)
{    does_something;
     put value calculated in result;
}
function main
{    for(n=1;n<30000;n++)
     {   set value of n;
         create pthread with address of function solve_for_n;
         wait for reply from pthread;
         if 5 seconds have passed tell pthread to exit;
     }
}

n is variable set by main .
Similiarly result is set by solve_for_n
I want to give 5 seconds maximum to pthread for solving else it should exit .
There are many more n values waiting in line .

Now , here is my code

#include<stdio.h>
#include<pthread.h>
#include<sys/time.h>
#define micro_second_multiplier 1000000

float interval;
unsigned long long int m;
unsigned int done,length,n;
int bye;
pthread_mutex_t timeisup;
void * solveforn(void *arguments)
{   
    unsigned long long int multiplicant,sum,quotient,divisor,product,multiplicantincremented,multiplicantdivisor;
    unsigned int flag,lenofn,maxnumofdigitinproduct,lenmultiplicant,digit;
    struct timeval begin, end;

    gettimeofday(&begin, NULL);
    printf("\nPthread begins");
    lenofn=0;
    divisor=10ll;
    do
    {   quotient=((unsigned long long)n)/divisor;
        divisor=divisor*(10ll);
        lenofn++;
    }while(quotient!=(0ll));
for(multiplicant=multiplicantincremented=1ll,flag=0,lenmultiplicant=1,multiplicantdivisor=10ll;flag!=1;multiplicant++,multiplicantincremented++)
    {   if((multiplicant%(2ll)==(0ll))&&(n%5==0))
        {   multiplicant++;
            if(multiplicantincremented==multiplicantdivisor)
            {   lenmultiplicant++;
                multiplicantdivisor=multiplicantdivisor*(10ll);
            }
            multiplicantincremented++;
        }
        else if(multiplicantincremented==multiplicantdivisor)
            {   lenmultiplicant++;
                multiplicantdivisor=multiplicantdivisor*(10ll);
            }
        maxnumofdigitinproduct=lenmultiplicant+lenofn;
        m=((unsigned long long)n)*multiplicant;
        length=0;
        sum=0ll;
        product=1ll;
        divisor=10ll;
        do
        {   quotient=m/divisor;
            length++;
            digit=(m%divisor)/(divisor/(10ll));
            divisor=divisor*(10ll);
            if(digit==0)
            {   product=0ll;
                break;
            }
            else
            {   
                sum=sum+((unsigned long long)digit);
                product=product*((unsigned long long)digit);
                if( (sum<product) && (sum+((unsigned long long)maxnumofdigitinproduct)-((unsigned long long)length)<product) )
                {
                    product=0ll;
                    break;
                }
            }
        }while(quotient!=(0ll));
        if((sum>=product)&&(product!=(0ll)))
            flag=1;
        pthread_mutex_lock(&timeisup);
        if(bye==1)
        {   pthread_mutex_unlock(&timeisup);
            pthread_exit(NULL);
        }
        else
            pthread_mutex_unlock(&timeisup);
    }
    gettimeofday(&end, NULL);
    interval=(float)(end.tv_sec*micro_second_multiplier+end.tv_usec - begin.tv_sec*micro_second_multiplier-begin.tv_usec);
    done=1;
    printf("\nn=%d m=%llu length=%d %.f millisecond = %.f second done=%d",n,m,length,interval,interval/1000,done);
}

int main(void)
{   pthread_t sa;
    int err_pthread,count;
    FILE *fi;
    fi=fopen("log.txt","a+");
    for(n=1;n<=30000;n++)
    {   if(n%10==0)
            n++;
        printf("\nTrying n=%d",n);
        done=0;
        bye=0;
        err_pthread=pthread_create(&sa,NULL,&solveforn,NULL);
        if(err_pthread!=0)
                {   printf("\nError while creating pthread for n=%d",n);
        }
        else
        {   printf("\npthread created");
            pthread_join(sa,NULL);
            count=0;
            do
            {   sleep(1);
                printf("\n1 second gone");
                count++;
            }while((done!=1) && (count<5));
            if(done==1)
            {   fprintf(fi,"\nn=%d m=%llu length=%d %.f millisecond = %.f second",n,m,length,interval,interval/1000);
                printf("\nThread finished in < 5 seconds");
            }
            else
            {   fprintf(fi,"\nTIME LIMIT EXCEEDED IN N=%d",n);
                printf("\nTIME LIMIT EXCEEDED IN N=%d",n);
                pthread_mutex_lock(&timeisup);
                bye=1;
                pthread_mutex_unlock(&timeisup);
            }
        }
    }
    fclose(fi);
}

The points to note are
(1)mutex timeisup locked then data passing between main and solveforn is done.
Hope - i am able to explain my situation .
The problem is -
output is as follows
Trying n=1
pthread created
Pthread begins
n=1 m=1 length=1 28 millisecond = 0 second done=1
1 second gone
Thread finished in < 5 seconds
Trying n=2
pthread created
nothing

Second 'pthread begins' did not appear . Thanks.

Answer 1

There are some solutions like pthread_cancel or pthread_kill, but non of them are stright forward as you want. you must implement handlers and ...

There is no safe way for killing a thread created by pthread (you asked about exit), you should implement exit logic inside you thread function. Also you can wait for 5 second, if all threads exited (changed a flag with appropriate mutex) you can go away.

For pthread, How to kill child thread from the main thread

cancelling or killing a pthread

Also there is an asymmetry in lock/unlock calls, in your code, you have locked pthread_mutex_lock and checked for bye==1, if it was the mutex will be unlocked, but if bye != the mutex never be unlocked and in next iteration you will be blocked by mutex_lock which isn't right.