#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>
pthread_mutex_t lock;
sem_t sem;
int counter;
void init(int N)
{
    counter=N; ///variabila counter devine nr de threaduri trimis ca parametru
    if(pthread_mutex_init(&lock,NULL))
    {
        perror(NULL);
        return ;
    }
}
void barrier_point()
{

    pthread_mutex_lock(&lock);
    counter--;
    if(counter==0)
    {
        ///Cand in bariera au ajuns toate thread-urile
        sem_post(&sem);
///sem_post creste valoarea semaforului cu o unitate, iar daca sunt thread-uri blocate de semafor ,
///il elibereaza pe cel care a asteptat cel mai mult;

        return ;
    }
    pthread_mutex_unlock(&lock);
    sem_wait(&sem);
    ///Cat timp toate thread-urile nu au ajuns la bariera adica cat timp if-ul nu este respectat acestea sunt puse sa astepte
    ///sem_wait scade valoarea semaforului cu o unitate, iar daca semaforul are val 0 asteapta pana ia o val mai mare ca 0
    sem_post(&sem);///Se creste dinnou semaforul pt a putea fi eliberat si urmatoarele thread-uri

}
void* tfun(void *v)
{

	int *tid=(int*)v;
	printf("%d reached the barrir\n",*tid);
	barrier_point();
	printf("%d passed the barrier\n",*tid);
	free(tid);
	return NULL;
}
int main()
{
    if(sem_init(&sem , 0 , 0))
    {
        perror(NULL);
        return errno;
    }
    init(5);
    int i , *v;
    pthread_t tid[5];
    for(i=0;i<5;i++)   ///Se pornesc in parelel 5 thread-uri
    {
        v=malloc(sizeof(int));
        *v=i;
        if(pthread_create(&tid[i],NULL,tfun,v))
        {
            perror(NULL);
            return errno;
        }
    }
    for(i=0;i<5;i++)
    {
        if(pthread_join(tid[i],NULL))
        {
            perror(NULL);
            return errno;
        }
    }
    pthread_mutex_destroy(&lock);
    sem_destroy(&sem);
}

...........................................................................................

#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<pthread.h>
#include<errno.h>
#include<sys/wait.h>
#define MAX_RESOURSES 5
int available_resourses=MAX_RESOURSES;
pthread_t tid[5];
pthread_mutex_t lock;
int decrease_count(int count)
{
    pthread_mutex_lock(&lock); ///Cate un thread exclusiv face verificari , chiar daca in functie pot intra mai multe in paralel
	if(available_resourses<count)
		{
            pthread_mutex_unlock(&lock);
            ///Chiar daca thread-ul nu gaseste resurse suficiente, acesta da mai departe lacatul si iese din functie
		    return -1;
		}
	else
    {

		available_resourses=available_resourses-count;
        pthread_mutex_unlock(&lock);


        printf("Got %d resources %d remaining\n",count,available_resourses);
        return 0;
    }
}
int increase_count(int count)
{
    pthread_mutex_lock(&lock);
	available_resourses=available_resourses+count;

	printf("Released %d resources %d remaining\n",count,available_resourses);
	///Afisarea resurselor in momentul eliberarii lor trebuie facuta imediat dupa eliberare pt a nu arata o valoare gresita a
	///noilor resurse disponibile ce posibil a fost modificata de alt thread
	pthread_mutex_unlock(&lock);
	///printf("Released %d resources %d remaining\n",count,available_resourses);

	return 0;
}
void *functie(void* v)
{
    int *cont=(int*)v;
    int contt=*cont;
    while(decrease_count(contt)==-1)
        sleep(1);
///Thread-ul care nu a gasit suficiente resurse nu este omorat, ci adormit scurt timp ,timp in care celelalte posibil sa elibereze resurse
    increase_count(contt);
    free(cont);
    return NULL;

}

int main()
{
    pthread_t thr[10];
    int i,*contor;
     if(pthread_mutex_init(&lock,NULL))
    {
        perror(NULL);
        return errno;
    }
    for(i=1;i<5;i++)
    {
        contor=(int*)malloc(sizeof(int));
        *contor=i;
        if(pthread_create(&thr[i],NULL,functie,contor))
        {
            perror(NULL);
            return errno;
        }
    }
    for(i=1;i<=5;i++)
        if(pthread_join(thr[i],NULL))
    {
        perror(NULL);
        return errno;
    }
    pthread_mutex_destroy(&lock);

}