Współbieżność: wątki drukujące jeden "A" drugi "B" + semafory ograniczające

0

Witam,
jak w temacie - mam do napisania dwa wątki z czego jeden drukuje ciągle "A" a drugi "B". Potrzebuję też semaforów ( nie sprecyzowano ilu ), które będą ograniczały wypisanie znaków do co najwyżej dwóch, czyli możemy wypisać: "ABBABA..." ale nie można np. "AAABB".
Próbowałam coś stworzyć ale nie potrafię zrobić tak, żeby to było 1 lub 2 ( a nie np tylko "AABB" lub "AB" ).
Proszę o jakąś wskazówkę ;>

mój kod:

public class Watkiwatki {

    public static void main(String[] args) {
        Prog zadanie = new Prog();
        zadanie.uruchom();
    }
}

class Prog {
    Semaphore s1= new Semaphore(2);
    Semaphore s2= new Semaphore(1);
    
    public void uruchom(){
        Watek1 w1= new Watek1();
        Watek2 w2= new Watek2();

        w1.start();
        w2.start();
    }
    
    class Watek1 extends Thread{
        public void run(){
            for(int i=0;i<50;i++){
                try {
                    s1.acquire();
                } catch (InterruptedException ex) {
                    Logger.getLogger(Prog.class.getName()).log(Level.SEVERE, null, ex);
                }
                try {
                    s1.acquire();
                     s2.release();
                } catch (InterruptedException ex) {
                    Logger.getLogger(Prog.class.getName()).log(Level.SEVERE, null, ex);
                }
                System.out.print("A");
            }
        }
    }
    
    class Watek2 extends Thread{
        public void run(){
            for(int i=0;i<50;i++){
                try {
                    s2.acquire();
                     s1.release();
                     s1.release();
                } catch (InterruptedException ex) {
                    Logger.getLogger(Prog.class.getName()).log(Level.SEVERE, null, ex);
                }
                System.out.print("B");
            }
        }
    }
        
    }
0

trochę po cajmersku i na szybko ale działa :)
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class Watkiwatki {

	public static void main(String[] args) {
		Prog zadanie = new Prog();
		zadanie.uruchom();
	}
}

class Prog {
	private Semaphore s1 = new Semaphore(1, true);
	private AtomicInteger balance = new AtomicInteger(0); // +1 dla A, -1 dla B

	public void uruchom() {
		Watek w1 = new Watek("A", s1, balance);
		Watek w2 = new Watek("B", s1, balance);

		w1.start();
		w2.start();
	}
}

class Watek extends Thread {
	private Watki name;
	private Semaphore s1;
	private AtomicInteger balance;

	public Watek(String name, Semaphore s1, AtomicInteger balance) {
		this.name = Watki.getByName(name);
		this.s1 = s1;
		this.balance = balance;
	}

	public void run() {
		while (true) {
			if (!((name.equals(Watki.A) && balance.get() == 1) || (name
					.equals(Watki.B) && balance.get() == -1))) {
				try {
					s1.acquire();
					System.out.print(name);
					balance.addAndGet(name.getBalance());
					s1.release();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

enum Watki {
	A(1), B(-1);

	private int balance;

	private Watki(int balance) {
		this.balance = balance;
	}

	public int getBalance() {
		return balance;
	}

	public static Watki getByName(String name) {
		if (name.equals("A")) {
			return A;
		}
		return B;
	}
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1