Print Zero Even Odd solution and explanation

from threading import Lock, Condition

class ZeroEvenOdd:
    def __init__(self, n):
        self.n = n
        self.zero_lock = Lock()
        self.even_lock = Lock()
        self.odd_lock = Lock()
        self.zero_lock.acquire()
        self.even_lock.acquire()

    def zero(self, printNumber):
        for i in range(1, self.n + 1):
            self.zero_lock.acquire()
            printNumber(0)
            if i % 2 == 0:
                self.even_lock.release()
            else:
                self.odd_lock.release()

    def even(self, printNumber):
        for i in range(2, self.n + 1, 2):
            self.even_lock.acquire()
            printNumber(i)
            self.zero_lock.release()

    def odd(self, printNumber):
        for i in range(1, self.n + 1, 2):
            self.odd_lock.acquire()
            printNumber(i)
            self.zero_lock.release()

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

struct ZeroEvenOdd {
    int n;
    int current;
    pthread_mutex_t lock;
    pthread_cond_t zero_cond, odd_cond, even_cond;
};

void zero(struct ZeroEvenOdd *z, void (*printNumber)(int)) {
    for (int i = 1; i <= z->n; ++i) {
        pthread_mutex_lock(&z->lock);
        while (z->current != 0) {
            pthread_cond_wait(&z->zero_cond, &z->lock);
        }
        printNumber(0);
        z->current = (i % 2 == 0) ? 2 : 1;
        if (z->current == 1) {
            pthread_cond_signal(&z->odd_cond);
        } else {
            pthread_cond_signal(&z->even_cond);
        }
        pthread_mutex_unlock(&z->lock);
    }
}

void even(struct ZeroEvenOdd *z, void (*printNumber)(int)) {
    for (int i = 2; i <= z->n; i += 2) {
        pthread_mutex_lock(&z->lock);
        while (z->current != 2) {
            pthread_cond_wait(&z->even_cond, &z->lock);
        }
        printNumber(i);
        z->current = 0;
        pthread_cond_signal(&z->zero_cond);
        pthread_mutex_unlock(&z->lock);
    }
}

void odd(struct ZeroEvenOdd *z, void (*printNumber)(int)) {
    for (int i = 1; i <= z->n; i += 2) {
        pthread_mutex_lock(&z->lock);
        while (z->current != 1) {
            pthread_cond_wait(&z->odd_cond, &z->lock);
        }
        printNumber(i);
        z->current = 0;
        pthread_cond_signal(&z->zero_cond);
        pthread_mutex_unlock(&z->lock);
    }
}

import java.util.concurrent.Semaphore;

class ZeroEvenOdd {
    private int n;
    private Semaphore zeroSemaphore = new Semaphore(1);
    private Semaphore oddSemaphore = new Semaphore(0);
    private Semaphore evenSemaphore = new Semaphore(0);

    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            zeroSemaphore.acquire();
            printNumber.accept(0);
            if (i % 2 == 1) {
                oddSemaphore.release();
            } else {
                evenSemaphore.release();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i += 2) {
            oddSemaphore.acquire();
            printNumber.accept(i);
            zeroSemaphore.release();
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i <= n; i += 2) {
            evenSemaphore.acquire();
            printNumber.accept(i);
            zeroSemaphore.release();
        }
    }
}

const { Semaphore } = require('async-mutex');

class ZeroEvenOdd {
    constructor(n) {
        this.n = n;
        this.zeroSemaphore = new Semaphore(1);
        this.oddSemaphore = new Semaphore(0);
        this.evenSemaphore = new Semaphore(0);
    }

    async zero(printNumber) {
        for (let i = 1; i <= this.n; i++) {
            await this.zeroSemaphore.acquire();
            printNumber(0);
            if (i % 2 === 1) {
                this.oddSemaphore.release();
            } else {
                this.evenSemaphore.release();
            }
        }
    }

    async odd(printNumber) {
        for (let i = 1; i <= this.n; i += 2) {
            await this.oddSemaphore.acquire();
            printNumber(i);
            this.zeroSemaphore.release();
        }
    }

    async even(printNumber) {
        for (let i = 2; i <= this.n; i += 2) {
            await this.evenSemaphore.acquire();
            printNumber(i);
            this.zeroSemaphore.release();
        }
    }
}

#include <semaphore.h>

class ZeroEvenOdd {
private:
    int n;
    sem_t z, e, o;

public:
    ZeroEvenOdd(int n) {
        this->n = n;
        sem_init(&z, 0, 1);
        sem_init(&e, 0, 0);
        sem_init(&o, 0, 0);
    }

    // printNumber(x) outputs "x", where x is an integer.
    void zero(function<void(int)> printNumber) {
        for (int i = 0; i < n; ++i) {
            sem_wait(&z);
            printNumber(0);
            if (i % 2 == 0) {
                sem_post(&o);
            } else {
                sem_post(&e);
            }
        }
    }

    void even(function<void(int)> printNumber) {
        for (int i = 2; i <= n; i += 2) {
            sem_wait(&e);
            printNumber(i);
            sem_post(&z);
        }
    }

    void odd(function<void(int)> printNumber) {
        for (int i = 1; i <= n; i += 2) {
            sem_wait(&o);
            printNumber(i);
            sem_post(&z);
        }
    }
};