Поиск в файле в несколько потоков

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include "queue.h"
#include <time.h>
 
void clean(char*);
char *fname = "/home/yudgin/1.txt";
char *find = "lol";
char *replace = "qwerty";
int str_next;
Queue qu;
pthread_mutex_t lock_queue;
pthread_mutex_t lock_file;
 
void clean(char *str){
    int i;
    for(i = strlen(str)-1; i > -1; i--){
        str[i] = '\0';
    }
}
 
void *th_find(void *num){
    int t_id = (int)num, flag = 1; 
    printf("\nStart thread the search #%d \n", t_id+1);
    while(flag){
        pthread_mutex_lock(&lock_file);
        FILE *file = fopen(fname,"r");
        int num_str = str_next;
        int curr_str = 1;
        str_next++;
        char str[1000];
        while (fgets(str, 1000, file)){
            if(curr_str == num_str){
                break;
            }
            curr_str++;
        }
        if(feof(file) != 0){
            flag = 0;
            fclose(file);
            pthread_mutex_unlock(&lock_file);
            continue;
        }
        int size = strlen(str);
        if(size == 0){
            flag = 0;
            fclose(file);
            pthread_mutex_unlock(&lock_file);
            continue;
        }
        printf("Processing string (th_f %d): ", t_id+1);
        puts(str);
        char tmp[1000];
        int i, j, pos = 0;
        char arr[100], arr1[100], arr2[100], buf[10];
        arr[0] = arr1[0] = arr2[0] = '\0';
        sprintf(buf, "%d", curr_str);
        strcpy(arr1, buf);
        arr1[strlen(arr1)] = '\0';
        for(i = 0, j = 0; i < strlen(str); i++){
            if(str[i] == ' ' || str[i] == '\n' || str[i] == '\0'){
                tmp[j] = '\0';
                j=0;
                if(strcmp(tmp, find) == 0){
                    strcat(arr2, " ");
                    char buf1[10];
                    sprintf(buf1, "%d", pos);
                    strcat(arr2, buf1);
                }
                strcpy(tmp, "");
                pos = i+1;
                continue;
            }
            tmp[j] = str[i];
            j++;
        }
        arr2[strlen(arr2)] = '\0';
        if(strlen(arr2) > 0){
            strcpy(arr, arr1);
            strcat(arr, arr2);
            pthread_mutex_lock(&lock_queue);
            Put(&qu, &arr);
            pthread_mutex_unlock(&lock_queue);
        }
        clean(str);
        fclose(file);
        pthread_mutex_unlock(&lock_file);
    } 
    printf("End th_f #%d\n", t_id+1);
    pthread_exit(NULL);
}
 
void *th_repl(void *num){
    int t_id = (int)num;
    printf("\nStart thread replacement #%d \n", t_id+1);
    while(1){
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
        pthread_mutex_lock(&lock_queue);
        if(Size(&qu) == 0){
            pthread_mutex_unlock(&lock_queue);
            sleep(3);
            continue;
        }
                
        char buf[10], *arr = Pop(&qu);
        pthread_mutex_unlock(&lock_queue);
        pthread_mutex_lock(&lock_file);
        FILE *file = fopen(fname,"r");
        Queue q;
        Create(&q);
        int i, j = 0, flag = 1;
        for(i = 0; i < strlen(arr); i++, j++){
            if(arr[i] == ' ' || arr[i] == '\n'){
                buf[j] = '\0';
                break;
            }
            buf[j] = arr[i];
            arr[i] = ' ';
        }
        int num_str = atoi(buf);
        int curr_str = 1;
        char str[1000];
        while (fgets(str, 1000, file)){
            if(curr_str == num_str){
                char str2[1000];
                str2[j] = '\0';
                int y = 0, u = 0;
                for(i = 0; i < strlen(arr); i++){
                    int pos;
                    char buff[10];
                    j = 0;
                    while(arr[i] == ' '){
                        i++;
                    }
                    while(arr[i] != ' ' && arr[i] != '\0'){
                        buff[j] = arr[i];
                        arr[i] = ' ';
                        i++;
                        j++;
                    }
                    buff[j] = '\0';
                    pos = atoi(buff);
                    for(; y < strlen(str); y++){
                        if(y == pos){
                            strcat(str2, replace);
                            u = u + strlen(replace);
                            y = y + strlen(find);
                            break;
                        }
                        str2[u] = str[y];
                        u++;
                    }
                    clean(buff);
                }  
                for(; y < strlen(str); y++, u++){
                    str2[u] = str[y];
                }
                str2[u] = '\0';
                printf("R #%d - string %d - replaced by: ", t_id+1, num_str);
                puts(str2);
                Put(&q, str2);
                clean(str2);
            }else{
                Put(&q, str);
            }
            clean(str);
            curr_str++;
        }
        printf("\n");
        fclose(file);
        file = fopen(fname,"w");
        while(isHead(&q)){
            fputs(Pop(&q), file);
        }
        fclose(file);
        pthread_mutex_unlock(&lock_file);
        Destroy(&q);
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    }
    printf("End th_r #%d", t_id+1);
    pthread_exit(NULL);
}
 
int main(int argc, char** argv) {
    clock_t t0 = clock();
    printf("Start\n");
    int kol_th_f = 3;
    int kol_th_r = 3;
    str_next = 1;
    Create(&qu);
    if(pthread_mutex_init(&lock_queue, NULL) != 0 || pthread_mutex_init(&lock_file, NULL) != 0){
        printf("\nMutex init failed\n");
        return 1;
    }
    pthread_t thread_f[kol_th_f]; 
    pthread_t thread_r[kol_th_r]; 
    int i;
    
    for(i = 0; i < kol_th_f; i++){
        pthread_create(&thread_f[i], NULL, th_find, (void*)i);
    }
        
    for(i = 0; i < kol_th_r; i++){
        pthread_create(&thread_r[i], NULL, th_repl, (void*)i);
    }
    
    for(i = 0; i < kol_th_f; i++){
        pthread_join(thread_f[i], NULL);
    }
    
    int flag = 1;
    while(flag){
        pthread_mutex_lock(&lock_queue);
        if(Size(&qu) == 0){
            for(i = 0; i < kol_th_r; i++){
                pthread_cancel(thread_r[i]);
            }
            flag = 0;
        }
        pthread_mutex_unlock(&lock_queue);
    }
    
    
    pthread_mutex_destroy(&lock_queue);
    pthread_mutex_destroy(&lock_file);
    Destroy(&qu);
    clock_t t1 = clock();
    printf("Time: %lf\n", (double)(t1-t0)/CLOCKS_PER_SEC);
    printf("End");    
}

typedef struct _Element {
    char val[1000];
    struct _Element *next;
} Element;
 
typedef struct {
    Element *head, *tail;
    int size;
}Queue;
 
void Create(Queue *qu){
    qu->head = qu->tail = NULL;
    qu->size = 0;
}
 
void Destroy(Queue *qu){
    while(qu->head){
        qu->tail = qu->head;
        qu->head = qu->head->next;
        free(qu->tail);
    }
    qu->head = qu->tail = NULL;
    qu->size = 0;
}
 
int isHead(Queue *qu){
    if(qu->head) return 1;
    else return 0;
}
 
int Size(Queue *qu){
    return qu->size;
}
 
int Put(Queue *qu, char *v){
    Element *tmp = (Element*)malloc(sizeof(Element));
    if(!tmp)
        return 0;
    tmp->next = NULL;
    if(qu->size == 0){
        qu->head = qu->tail = tmp;
    }else{
        qu->tail->next = tmp;
        qu->tail = tmp;
    }
    qu->size++;
    strcpy(tmp->val, v);
    return 1;
}
 
char* Pop(Queue *qu){
    Element *tmp = (Element*)malloc(sizeof(Element));
    if(!qu->head) 
        return NULL;
    tmp = qu->head;
    qu->head = qu->head->next;
    if(!qu->head)
        qu->tail = NULL;
    qu->size--;
    return tmp->val;
}