Programming

sleep(5);

 
#include <stdio.h>
#include <stdlib.h>
#include <curses.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_SIZE 10
int Counter;
struct Stack
{
 int home[MAX_SIZE];
 int top;
};
struct Stack s;
void InitStack(struct Stack *s)
{
 s->top = -1;
 Counter = 0;
}
void Push(struct Stack *s, int x)
{
 if(s->top == MAX_SIZE-1)
 {
  printf("Stack is full!\n");
  exit(0);
 }
 else
 s->top++;
 s->home[s->top] = x;
 Counter++;
 printf("Counter = %d\n", Counter);
}
void Pop(struct Stack *s)
{
 int y;
 if(s->top == -1)
 {
  printf("Stack empty!\n");
  exit(0);
 }
 else
 y = s->home[s->top];
 s->top--;
 printf("%d poped\n",y);
 Counter--;
 printf("Counter = %d\n", Counter);
}

void *threadA(void *);
void *threadB(void *);
int main()
{
 InitStack(&s); 
 int i, j, k;
 pthread_t tid[2];
 pthread_attr_t attr[2];
 for(i=1;i<=2;i++)
 {
  pthread_attr_init(&attr[i-1]);
 }
  {
  pthread_create(&tid[0],&attr[0],threadA,(void *)786);
  pthread_create(&tid[1],&attr[1],threadB,(void *)786);
  }
 { 
 pthread_join(tid[0],NULL);
 pthread_join(tid[1],NULL);
 }
return 0;
}

void *threadA(void *n)
{
 int x;
 x = (int)n;
 while(1) 
 {
 if(Counter != MAX_SIZE)
 {
 Push(&s,x);
 printf("x = %d\n", x);
 sleep(1);
 }
 else
 {
 printf("Going for a long sleep as Stack is full!\n");
 sleep(50);
 }
 }
}
void *threadB(void *n)
{
 int x;
 sleep(15);
 while(1)
 {
 if(Counter != 0)
 {
 Pop(&s);
 sleep(1);
 }
 else
 {
 printf("Going for a long sleep as Stack is empty!\n");
 sleep(50);
 }
 }
}

#include <pthread.h>
#include <stdio.h>

// Simplest way to create a mutex, no function calls needed
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

// When two threads must use the same memory, you must use
// mutex calls to make it safe.  It's not just a lock, it's also a
// "memory barrier", guaranteeing memory values between different CPU cores
// are synchronized properly.
int running=1;

void *thread(void *arg)
{
        fprintf(stderr, "Thread beginning\n");
        while(1)
        {
                int r;
                fprintf(stderr, "thread waiting for lock\n");
                // If main already has the mutex, thread will sleep.
                // when main unlocks it, the thread will lock it and continue.
                pthread_mutex_lock(&lock);
                        fprintf(stderr, "We have the mutex, it is safe to get value of 'running'\n");
                        r=running;
                        fprintf(stderr, "Value of 'running' is %d\n", r);
                pthread_mutex_unlock(&lock); // What gets locked MUST be unlocked later!
                fprintf(stderr, "thread has given up the lock\n");
                if(r == 0) break;
                sleep(1);
        }
        fprintf(stderr, "thread finishing\n");

        return((void *)0xdeadbeef);
}

int main()
{
        void *ret;
        pthread_t tid;
        running=1;
        pthread_mutex_lock(&lock); // Stop thread from getting the mutex
        fprintf(stderr, "main now has the mutex\n");

        pthread_create(&tid, NULL, thread, NULL);
        sleep(2); // Thread will begin, but wait for mutex

        fprintf(stderr, "main is unlocking the mutex\n");
        pthread_mutex_unlock(&lock); // Let the thread run for a while
        sleep(5);

        // Lock the mutex, making it safe to alter 'running'
        pthread_mutex_lock(&lock);
                fprintf(stderr, "main now has the mutex\n");
                running=0;
                fprintf(stderr, "main is unlocking the mutex\n");
        pthread_mutex_unlock(&lock);

        pthread_join(tid, &ret);
        fprintf(stderr, "Thread finished with return value %p\n", ret);
}