I am working on one project in which i need to read from 80 or more clients and then write their o/p into a file continuously and then read these new data for another task. My question is what should i use select or multithreading?

Also I tried to use multi threading using read/fgets and write/fputs call but as they are blocking calls and one operation can be performed at one time so it is not feasible. Any idea is much appreciated.

update 1: I have tried to implement the same using condition variable. I able to achieve this but it is writing and reading one at a time.When another client tried to write then it cannot able to write unless i quit from the 1st thread. I do not understand this. This should work now. What mistake i am doing?

Update 2: Thanks all .. I am able to succeeded to get this model implemented using mutex condition variable.

updated Code is as below:

        **header file*******
         char    *mailbox ;
    pthread_mutex_t  lock  = PTHREAD_MUTEX_INITIALIZER ;
    pthread_cond_t   writer = PTHREAD_COND_INITIALIZER;

    int main(int argc,char *argv[])
    {
      pthread_t          t1 , t2;
      pthread_attr_t     attr;
      int            fd, sock , *newfd;
      struct sockaddr_in cliaddr;
      socklen_t      clilen;
      void          *read_file();
      void          *update_file();

      //making a server socket
      if((fd=make_server(atoi(argv[1])))==-1)
        oops("Unable to make server",1)


      //detaching threads
      pthread_attr_init(&attr);
      pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

      ///opening thread for reading
      pthread_create(&t2,&attr,read_file,NULL);

      while(1)
      {
        clilen = sizeof(cliaddr);
        //accepting request
        sock=accept(fd,(struct sockaddr *)&cliaddr,&clilen);

        //error comparison against failire of request and INT
        if(sock==-1 && errno != EINTR)
                oops("accept",2)
        else if ( sock ==-1 && errno == EINTR)
            oops("Pressed INT",3)

        newfd = (int *)malloc(sizeof(int));
        *newfd = sock;
        //creating thread per request
        pthread_create(&t1,&attr,update_file,(void *)newfd);
      } 
     free(newfd);
     return 0;
    }

    void *read_file(void *m)
    {
        pthread_mutex_lock(&lock);
        while(1)
        {
            printf("Waiting for lock.\n");
        pthread_cond_wait(&writer,&lock);
            printf("I am reading here.\n");
            printf("%s",mailbox);
            mailbox = NULL ;
        pthread_cond_signal(&writer);
        }
    }


    void *update_file(int *m)
    {
       int  sock = *m;
       int  fs ; 
       int  nread;
       char buffer[BUFSIZ] ;

       if((fs=open("database.txt",O_RDWR))==-1)
          oops("Unable to open file",4)

       while(1)
       {
        pthread_mutex_lock(&lock);
        write(1,"Waiting to get writer lock.\n",29);

        if(mailbox != NULL)
           pthread_cond_wait(&writer,&lock);

            lseek(fs,0,SEEK_END);
            printf("Reading from socket.\n");
            nread=read(sock,buffer,BUFSIZ);
            printf("Writing in file.\n");
            write(fs,buffer,nread);
            mailbox = buffer ;
          pthread_cond_signal(&writer);
          pthread_mutex_unlock(&lock);
       }
        close(fs);
    }