Синхронизация потоков без использования mutex

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
void* write_thread (void*);
void* read_thread (void*);
int bufer[10], w=0, r=0, a=0, x, thread_done=0;
pthread_mutex_t my_sync; // Инициализируем мьютекс
pthread_cond_t rx; // Инициализируем условную переменную
int main ()
{
    pthread_t tid1, tid2; // Инициализация потоков
    pthread_mutex_init (&my_sync, NULL); // Инициализация мьютекса
    pthread_cond_init (&rx, NULL); // Инициализация условной переменной
    pthread_create (&tid1, NULL, write_thread, (void *) NULL); // Создаем поток записи
    pthread_create (&tid2, NULL, read_thread, (void *) NULL); // Создаем поток чтения
    pthread_join (tid1, NULL); // Ждем завершения потоков
    pthread_join (tid2, NULL);
}
void* write_thread (void* dummy) // Функция записи
{
    for (;;) // Бесконечный цикл
    {
        pthread_mutex_lock(&my_sync); // Захватываем мьютекс
        if (thread_done==10) pthread_cond_wait(&rx, &my_sync); // Если пытаемся писать в полный буфер - блокируем поток записи и переходим в поток чтения
        if (a>9) {a=0;} // Если символ больше 10 - обнуляем
        bufer[w]=a; // Записываем в буфер символ
        a++; // Увеличиваем символ на единицу
        thread_done++; // Инкрементируем флаг заполнения буфера
        printf ("\nЗаписан символ buffer[%d]=%d\n", w, bufer[w]); // Выводим записанный символ
        w++; // Инкрементируем индекс массива-буфера
        if (w==10) {w=0;} // Если индекс буфера равен 10 - обнуляем
        pthread_cond_signal (&rx); // "Будим" поток чтения
        pthread_mutex_unlock (&my_sync); // Освобождаем мьютекс
        x=rand()%2500000+500000; // Случайное число секунд от 0,5 до 2
        usleep(x); // Пауза
    }
        return;
}
void* read_thread (void* dummy) // Функция чтения
{
    for (;;)
    {
        pthread_mutex_lock(&my_sync);
        if (thread_done==0) pthread_cond_wait(&rx, &my_sync); // Если пытаемся читать из пустого буфера - блокируем поток чтения и переходим в поток записи
        thread_done--; // Декрементируем флаг заполнения буфера
        printf ("\n  Считан символ buffer[%d]=%d\n", r, bufer[r]); // Выводим считанный символ
        r++;
        if (r==10) {r=0;}
        pthread_cond_signal (&rx); // "Будим" поток записи
        pthread_mutex_unlock (&my_sync);
        x=rand()%2500000+500000;
        usleep(x);
    }
        return;
}

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <time.h>
#include <assert.h>
#include <errno.h>
#include <signal.h>
 
sem_t sem;
 
#define handle_error(msg) \
   do { perror(msg); exit(EXIT_FAILURE); } while (0)
 
static void
handler(int sig)
{
   write(STDOUT_FILENO, "sem_post() from handler\n", 24);
   if (sem_post(&sem) == -1) {
      write(STDERR_FILENO, "sem_post() failed\n", 18);
      _exit(EXIT_FAILURE);
   }
}
 
int
main(int argc, char *argv[])
{
   struct sigaction sa;
   struct timespec ts;
   int s;
 
   if (argc != 3) {
      fprintf(stderr, "Usage: %s <alarm-secs> <wait-secs>\n",
               argv[0]);
      exit(EXIT_FAILURE);
   }
 
   if (sem_init(&sem, 0, 0) == -1)
      handle_error("sem_init");
 
   /* Establish SIGALRM handler; set alarm timer using argv[1] */
 
   sa.sa_handler = handler;
   sigemptyset(&sa.sa_mask);
   sa.sa_flags = 0;
   if (sigaction(SIGALRM, &sa, NULL) == -1)
      handle_error("sigaction");
 
   alarm(atoi(argv[1]));
 
   /* Calculate relative interval as current time plus
      number of seconds given argv[2] */
 
   if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
      handle_error("clock_gettime");
 
   ts.tv_sec += atoi(argv[2]);
 
   printf("main() about to call sem_timedwait()\n");
   while ((s = sem_timedwait(&sem, &ts)) == -1 && errno == EINTR)
      continue;       /* Restart if interrupted by handler */
 
   /* Check what happened */
 
   if (s == -1) {
      if (errno == ETIMEDOUT)
            printf("sem_timedwait() timed out\n");
      else
            perror("sem_timedwait");
   } else
      printf("sem_timedwait() succeeded\n");
 
   exit((s == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
}