#ifndef MY_THREAD_H

#define MY_THREAD_H



//Ces macros servent à uniformiser certaines fonctionnalités entre Windows et Linux.

#ifdef WIN32 //macro version Windows



#   include <windows.h>



    //definition des threads



#   define callback_t                       unsigned long __stdcall



#   define thread_t                         HANDLE*

#   define thread_create(thrd, fct, param)  thrd = new HANDLE;\

                                            *(thrd) = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(fct),(param),0,NULL)

#   define thread_delete(thrd)              CloseHandle(*(thrd));\

                                            delete (thrd);

#   define thread_wait_close(thrd)          WaitForMultipleObjects(1, *thrd, TRUE, INFINITE)



    //definition des semaphores et mutex



#   define mutex_t                          CRITICAL_SECTION

#   define mutex_init(mutex)                InitializeCriticalSection((mutex))

#   define mutex_lock(mutex)                EnterCriticalSection((mutex))

#   define mutex_unlock(mutex)              LeaveCriticalSection((mutex))

#   define mutex_delete(mutex)              DeleteCriticalSection((mutex))



#   define semaphore_t                      HANDLE

#   define semaphore_init(sema, max, place) ((sema) = CreateSemaphore(NULL, (max), (place), NULL))

#   define semaphore_lock(sema)             WaitForSingleObject((sema), INFINITE)

#   define semaphore_unlock(sema)           ReleaseSemaphore((sema), 1, NULL)

#   define semaphore_delete(sema)           CloseHandle(sema)



#else //macro version Linux



    //definition des threads



#   include <pthread.h>



#   define callback_t                       void * 



#   define thread_t                         pthread_t*

#   define thread_create(thrd, fct, param)  (thrd) = new pthread_t;\

                                            pthread_create((thrd), NULL, (fct), (param))

#   define thread_delete(thrd)              delete (thrd);

#   define thread_wait_close(thrd)          pthread_join(*thrd, NULL)



    //definition des semaphores et mutex



#   include <semaphore.h>



#   define mutex_t                          pthread_mutex_t *

#   define mutex_init(mutex)                (mutex) = new pthread_mutex_t;\

                                            pthread_mutex_init ((mutex), NULL)

#   define mutex_lock(mutex)                pthread_mutex_lock((mutex))

#   define mutex_unlock(mutex)              pthread_mutex_unlock((mutex))

#   define mutex_delete(mutex)              pthread_mutex_destroy((mutex));\

                                            delete ((mutex))



#   define semaphore_t                      sem_t*

#   define semaphore_init(sema, max, place) (sema) = new sem_t;\

                                            sem_init ((sema), (max), (place))

#   define semaphore_lock(sema)             sem_wait((sema))

#   define semaphore_unlock(sema)           sem_post((sema))

#   define semaphore_delete(sema)           sem_destroy((sema));\

                                            delete ((sema))



#endif



#endif

                 ________________
                |                |
                | Code Principal |
                |________________|
                        |
                    intruction...
                        |                ________________
                        |               |                |
                execution du thread  -> | Code du thread |
                        |               |________________|
                        |                       |
                        |                       |
                    intruction...          intruction...
                        |                       |
                        |                       |
                        |-----------------------|
                        |
                   Fin du prog

#include <iostream>
#include "mythread.h"

//creation du mutex
mutex_t mut;
mutex_t io;

void trace(int x)
{
    //Vue que trace est appeler par un thread 
    //et qu'elle utilise les entrers sorties
    //il faut utiliser un autre mutex
    
    //ATTENTION voici la zone critique seule un thread à le droit 
    //d'utiliser l'ES
    
    mutex_lock(io);
        printf("x = %d\n", x);
    mutex_unlock(io);
    
    //Fin de zone critique
    //un thread en file d'attente peut rentrer
    
    return;
};

callback_t maFonc(void* x)
{
    //recastage de x
    int* intX = (int*)
    
    
    //ATTENTION voici la zone critique seule un thread à le droit 
    // de modifier la veleur de X
    
    mutex_lock(mut);
        //multiplication de x par lui même
        *intX = *intX * *intX;
    mutex_unlock(mut);
    
    //Fin de zone critique
    //un thread en file d'attente peut rentrer
    
    trace(*intX);
    
    return NULL;
};

int main()
{
    //Création de x
    int x;
    
    //initialisation du mutex
    mutex_init(mut);
    mutex_init(io);
    
    //Creation des threads
    thread_t thrd[10];
    int i;
    for(i = 0; i < 10; i++)
        thread_create(thrd[i], maFonc, &x);
    
    //attente de la fermeture des threads
    for(i = 0; i < 10; i++)
        thread_wait_close(thrd[i]);
    
    //destruction des threads et du mutex
    for(i = 0; i < 10; i++)
        thread_delete(thrd);
        
    mutex_delete(mutex);
    mutex_delete(io);
    
    printf("\n\nX Final = %d\n", x);
    
    return 0;
};

#include <iostream>
#include "mythread.h"

//creation du mutex
mutex_t mut;

void trace(int x)
{
    printf("x = %d\n", x);
    
    return;
};

callback_t maFonc(void* x)
{
    //recastage de x
    int* intX = (int*)
    
    
    //ATTENTION voici la zone critique seule un thread à le droit 
    // de modifier la veleur de X
    
    mutex_lock(mut);
        //multiplication de x par lui même
        *intX = *intX * *intX;
        trace(*intX);
    mutex_unlock(mut);
    
    //Fin de zone critique
    //un thread en file d'attente peut rentrer
    
    return NULL;
};

int main()
{
    //Création de x
    int x;
    
    //initialisation du mutex
    mutex_init(mut);
    
    //Creation des threads
    thread_t thrd[10];
    int i;
    for(i = 0; i < 10; i++)
        thread_create(thrd[i], maFonc, &x);
    
    //attente de la fermeture des threads
    for(i = 0; i < 10; i++)
        thread_wait_close(thrd[i]);
    
    //destruction des threads et du mutex
    for(i = 0; i < 10; i++)
        thread_delete(thrd);
        
    mutex_delete(mutex);
    
    printf("\n\nX Final = %d\n", x);
    
    return 0;
};

create_semaphore(sema, 10, 2);

create_semaphore(sema, 10, 10);