Utilisé du multithread sous unix (C++)

Bonjour, très probablement qu'il existe déja un poste dans lequel il est expliquer ce que je vais dès maintenant vous demander... mais je pers patience... après avoir visité une quantité indénombrable de sites... je n'arrive pas a trouver mon bonheur!
En effet, je recherche un totoriel en français permettant de comprendre le fonctionnement du multithread, que je compte utilisé pour une application de communication (Client / Serveur) sur un system UNIX; avec la possibilité de connecter plusieur serveur. Le serveur ne servant par conséquent, que d'un relai, normale me direz vous.
Je vous montre ci-contre le code que je veux 'multithreadé' (ne juger pas trop méchament ^^ je suis étudiant, et j'ai beaucoup a apprendre) Pour ceux qui prendront le temps de lire ce poste, et d'essayer de m'aider, je vous en remercie d'avance, amicalement, un future développeur comme vous ;)

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <netdb.h>
#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

#define TAILLEMAX 256
#define PORT 2708
#define SOCKET_ERROR -1
#define INVALID_SOCKET -1
#define CONNEXION_MAX 3

    class connexion
    {
    private:
    struct sockaddr_in serv_ad, client_ad,sin;
    int sockd,sockcli,ex;
    public:

    connexion()
    {
    sockd=socket(AF_INET,SOCK_STREAM,0);
    }

    int getException()
    {
    return ex;
    }

    void init(int domaine,int type )
    {
    serv_ad.sin_family = domaine;
    serv_ad.sin_addr.s_addr = type;
    serv_ad.sin_port = htons(PORT);
    }

    int c_bind()
    {
    int res = bind(sockd,(struct sockaddr*)&serv_ad,sizeof(serv_ad));
    return res;
    }

    int c_listen()
    {
    return listen(sockd,100);
    }

    unsigned int sizeOfSin()
    {
    return sizeof(sin);
    }

    int c_accept(unsigned int size)
    {
    return (sockcli = accept(sockd,(struct sockaddr*)&sin, &size));
    }

    int c_read(char machaine[TAILLEMAX])
    {
    char ch[TAILLEMAX];
    int res = (read(sockcli,ch,sizeof(ch)));
    strcpy(machaine,ch);
    return res;
    }

    int c_write(char machaine[TAILLEMAX])
    {
    char envoi[TAILLEMAX];
    strcpy(envoi,machaine);
    int res = write(sockcli,envoi,sizeof(envoi));
   
    return res;
    }

    void c_close()
    {
    close(sockcli);
    }

    int c_connect()
    {
    sockcli=sockd;
    return (connect(sockd,(struct sockaddr*)&serv_ad,sizeof(serv_ad)));
    }

    };


int main(int argc, char *argv[]){
connexion serveur;
unsigned int sin_size;
int ecoute,conn_serv;
char ch[TAILLEMAX],taille,ret,recu[TAILLEMAX];
char * quit ="/quit\0";

//ouverture de la socket socket.open
;
if(serveur.getException() ==-1)
{
printf("Erreur
socket\n");
return -1; }   
       
serveur.init(AF_INET,htonl(INADDR_ANY));

if (serveur.c_bind()  == SOCKET_ERROR)
{      // liaison à la socket
    printf("Erreur bind \n");
    return -1;
} 

conn_serv = 0;

  do
  { 
  cout << "Serveur en ecoute...\n";
  }while((ecoute = serveur.c_listen()) != 0);
  cout << "Tentative de connexion " <<conn_serv+1 << "\n";
  if(ecoute == SOCKET_ERROR)
  {
            cout << "Connexion failed\n";
            return EXIT_FAILURE;
  }
  
  //Accepte la connexion
  // structure destinée à recueillir les renseignements sur l'appelant
  sin_size = serveur.sizeOfSin();
  if(serveur.c_accept(sin_size) == INVALID_SOCKET)
  {
        cout<<"Tentative de connexion Superieur à" <<conn_serv+1<<"\n";
            return EXIT_FAILURE;       
  };
  cout << "Acceptation de connexion\n";
  // connexion et envoi du message au client
  int retour;
 cout<<"Connexion etabli\n";
int bcle = 1;

do
{
fflush(stdin);
fflush(stdout);
    ret = (serveur.c_read(ch)==-1);
      if(ret ==-1)
    {
        cout <<"Receive error\n";
        return EXIT_FAILURE;
    }
    if(ch[0] == quit[0] && ch[1] == quit[1] && ch[2] == quit[2] && ch[3] == quit[3] && ch[4] == quit[4])
    {
        bcle = 0;
        cout << "Deconnexion du client\n";
    }
else
{
       cout<<"Client: "<<ch<<"\n";
    cout<<"Entrez le mot a envoyer : ";
    fgets(recu,TAILLEMAX,stdin);
    fflush(stdin);
    fflush(stdout);
    ret = serveur.c_write(recu);
    if(recu[0] == quit[0] && recu[1] == quit[1] && recu[2] == quit[2] && recu[3] == quit[3] && recu[4] == quit[4])
    {
        bcle = 0;
        cout<<"Deconnexion\n";
    }
else
{
      if (ret == SOCKET_ERROR) 
      {  
       cout<<"Erreur envoi \n";
        return EXIT_FAILURE;
      }
    ret = -1;

cout<<"------MESSAGE ENVOYEE------\n";
}
}     
}while(bcle);
serveur.c_close();
return 0;
}

Merci de tes réponses, je vais de ce pas me plonger  dans les liens que tu m'as envoyé.
Et étudier tout cela, encore merci ;)

En faite, je n'ai rien trouvé qui puisse réellement m'aider, du coup, je vais étendre mes recherche a la fonction   "FORK"