[Risolto]Produttore consumatore (thread)

Salve a tutti come da titolo ho bisogno di una piccola mano con questo esercizio: creare M produttori e N consumatori in thread i produttori devono produrre K messaggi (in media ogni produttore fa K/M messaggi i rimanenti, se ci sono, li fa l'ultimo thread creato). I consumatori devono "leggere" ed eliminare i messaggi fino a quando incontrano un messaggio con scritto STOP.

Io ho scritto questo:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <errno.h>

typedef struct bcoda{
	char *m;
	struct bcoda *next;
}nodo;

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

static nodo *coda=NULL;
static int fine;

void lock_acquire(pthread_mutex_t *mtx){ 
	int err;
	if ( ( err=pthread_mutex_lock(mtx)) != 0 ) {
		errno=err;
		perror("lock");
		pthread_exit(errno); 
	}
}

void lock_release(pthread_mutex_t *mtx){ 
	int err;
	if ( ( err=pthread_mutex_unlock(mtx)) != 0 ) {
		errno=err;
		perror("lock");
		pthread_exit(errno); 
	}
}

nodo *add(nodo *buf,char *w){
	if(buf==NULL){
		nodo *new=malloc(sizeof(nodo));
		int l=strlen(w);
		l++;
		new->m=malloc(l*sizeof(char));
		strcpy(new->m,w);
		new->next=NULL;
		return new;
	}else{
		buf->next=add(buf->next,w);
	}
	return buf;
}

static void *produttore(int n){
	int x=n;
	while(x>0){
		lock_acquire(&mtx);
		if(fine==1){
			coda=add(coda,"STOP");
		}else{
			coda=add(coda,"CIAO");
			fine--;
		}
		pthread_cond_signal(&cond);
		lock_release(&mtx);
		x--;
	}
}

static void *consumatore(){
	while(1){
		lock_acquire(&mtx);
		while(coda==NULL){
			pthread_cond_wait(&cond,&mtx);
		}
		if(strcmp(coda->m,"STOP")!=0){
			nodo *temp=coda;
			coda=coda->next;
			free(temp);
			lock_release(&mtx);
		}else{
			pthread_cond_signal(&cond);
			lock_release(&mtx);
			break;
		}
	}
}
		
int main(){
	int i,M,N,K,err,count=0;
	int messxtrd;
	printf("Quanti produttori? ");
	scanf("%d",&M);
	printf("Quanti consumatori? ");
	scanf("%d",&N);
	printf("Quanti messaggi vuoi far produrre? ");
	scanf("%d",&K);
	fine=K;
	pthread_t *trd;
	i=M+N;
	trd=malloc(i*sizeof(pthread_t));
	messxtrd=K/M;
	for(i=0;i<M;i++){
		if(i==(M-1)){
			messxtrd=(K-count);
		}
		err=pthread_create(&trd[i],NULL,&produttore,messxtrd);
		if(err<0){
			perror("thread");
			exit(EXIT_FAILURE);
		}
		count+=messxtrd;
	}
	for(i=0;i<N;i++){
		err=pthread_create(&trd[i+M],NULL,&consumatore,NULL);
		if(err<0){
			perror("thread");
			exit(EXIT_FAILURE);
		}
	}
	for(i=0;i<(N+M);i++){
		pthread_join(trd[i],NULL);
	}
	printf("%s\n",coda->m);
	free(coda);
	return 0;
}

Attraverso vari test da me effettuati il problema mi sembra nei consumatori cioè che non tutti riescono a terminare però non capisco proprio il perchè (vedere il codice consumatore)...Qualcuno puo' aiutarmi? grazie