Print FooBar Alternately solution and explanation

from threading import Lock, Condition

class FooBar:
    def __init__(self, n):
        self.n = n
        self.lock = Lock()
        self.foo_turn = True
        self.foo_cond = Condition(self.lock)
        self.bar_cond = Condition(self.lock)

    def foo(self):
        for _ in range(self.n):
            with self.lock:
                while not self.foo_turn:
                    self.foo_cond.wait()
                print("foo", end='')
                self.foo_turn = False
                self.bar_cond.notify()

    def bar(self):
        for _ in range(self.n):
            with self.lock:
                while self.foo_turn:
                    self.bar_cond.wait()
                print("bar", end='')
                self.foo_turn = True
                self.foo_cond.notify()

import java.util.concurrent.locks.*;

class FooBar {
    private int n;
    private Lock lock;
    private Condition fooCond, barCond;
    private boolean fooTurn;

    public FooBar(int n) {
        this.n = n;
        lock = new ReentrantLock();
        fooCond = lock.newCondition();
        barCond = lock.newCondition();
        fooTurn = true;
    }

    public void foo() throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                while (!fooTurn) {
                    fooCond.await();
                }
                System.out.print("foo");
                fooTurn = false;
                barCond.signal();
            } finally {
                lock.unlock();
            }
        }
    }

    public void bar() throws InterruptedException {
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                while (fooTurn) {
                    barCond.await();
                }
                System.out.print("bar");
                fooTurn = true;
                fooCond.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}

class Semaphore {
    constructor(count = 1) {
        this.count = count;
        this.queue = [];
    }
    acquire() {
        return new Promise(resolve => {
            if (this.count > 0) {
                this.count -= 1;
                resolve();
            } else {
                this.queue.push(resolve);
            }
        });
    }
    release() {
        if (this.queue.length > 0) {
            const resolve = this.queue.shift();
            resolve();
        } else {
            this.count += 1;
        }
    }
}

class FooBar {
    constructor(n) {
        this.n = n;
        this.fooSemaphore = new Semaphore(1);
        this.barSemaphore = new Semaphore(0);
    }

    async foo(printFoo) {
        for (let i = 0; i < this.n; i++) {
            await this.fooSemaphore.acquire();
            printFoo();
            this.barSemaphore.release();
        }
    }

    async bar(printBar) {
        for (let i = 0; i < this.n; i++) {
            await this.barSemaphore.acquire();
            printBar();
            this.fooSemaphore.release();
        }
    }
}

function printFoo() {
    process.stdout.write('foo');
}

function printBar() {
    process.stdout.write('bar');
}

let fooBar = new FooBar(2);
Promise.all([fooBar.foo(printFoo), fooBar.bar(printBar)]);

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

sem_t foo_sem, bar_sem;

void *foo(void *arg) {
    int n = *(int *)arg;
    for (int i = 0; i < n; ++i) {
        sem_wait(&foo_sem);
        printf("foo");
        sem_post(&bar_sem);
    }
    return NULL;
}

void *bar(void *arg) {
    int n = *(int *)arg;
    for (int i = 0; i < n; ++i) {
        sem_wait(&bar_sem);
        printf("bar");
        sem_post(&foo_sem);
    }
    return NULL;
}

int main() {
    int n = 2;  // Example input
    pthread_t thread1, thread2;
    sem_init(&foo_sem, 0, 1);
    sem_init(&bar_sem, 0, 0);

    pthread_create(&thread1, NULL, foo, &n);
    pthread_create(&thread2, NULL, bar, &n);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    sem_destroy(&foo_sem);
    sem_destroy(&bar_sem);
    return 0;
}

#include <semaphore.h>

class FooBar {
private:
    int n;
    sem_t f, b;

public:
    FooBar(int n) {
        this->n = n;
        sem_init(&f, 0, 1);
        sem_init(&b, 0, 0);
    }

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            sem_wait(&f);
            // printFoo() outputs "foo". Do not change or remove this line.
            printFoo();
            sem_post(&b);
        }
    }

    void bar(function<void()> printBar) {
        for (int i = 0; i < n; i++) {
            sem_wait(&b);
            // printBar() outputs "bar". Do not change or remove this line.
            printBar();
            sem_post(&f);
        }
    }
};