Buenas,

estoy con programación concurrente, y la verdad es que me cuesta bastante. En este caso, el ejercicio propuesto es un programa cuya salida sea:
A
BB
CCC
A
BB
CCC
etc.

Donde cada hilo imprime su letra. Esto es lo que he hecho, cuya salida es correcta:

public class HiloLetra implements Runnable{
 
	char letra;
	int numVeces;
	Buffer buffer;	//Recurso compartido
	static int turno;
 
 
	public HiloLetra(char letra, int numVeces, Buffer buffer) {
		this.letra = letra;
		this.numVeces = numVeces;
		this.buffer = buffer;
	}
 
 
	@Override
	public void run() {
		while(true) {
			try {
				buffer.imprimirLetra(letra, numVeces);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
 

import java.util.concurrent.Semaphore;
 
 
public class Buffer {
 
	int numeroLetras;
	Semaphore arrayCandados[];
	int posicionArray;
 
 
	public Buffer(int numeroLetras) {
		this.numeroLetras = numeroLetras;
		arrayCandados = new Semaphore[this.numeroLetras];
		posicionArray = 0;
		crearCandados();
	}
 
	private void crearCandados() {
		arrayCandados[0] = new Semaphore(1);
		for(int i = 1; i < numeroLetras; i++) {
			arrayCandados[i] = new Semaphore(0);
		}
	}
 
	public void imprimirLetra(char letra, int numeroLetra) throws InterruptedException {
 
		while(numeroLetra-1 == posicionArray) {	
			arrayCandados[posicionArray].acquire(numeroLetra);
 
			for(int i = 0; i < numeroLetra; i++) {
				System.out.print(letra/*+", posicion array: "+posicionArray*/);
			}
			System.out.println();
 
			posicionArray++;
			if(posicionArray == numeroLetras) {
				posicionArray = 0;
			}
 
			arrayCandados[posicionArray].release(posicionArray+1);
		}
	}
}
 

public class Principal {
 
	final int NUMERO_LETRAS = 3;
 
 
	HiloLetra runnables[];
	Thread hilosLetras[];
	Buffer buffer;
 
 
	public Principal() {
		runnables = new HiloLetra[NUMERO_LETRAS];
		hilosLetras = new Thread[NUMERO_LETRAS];
		buffer = new Buffer(NUMERO_LETRAS);
		crearHilos();
	}
 
	private void crearHilos() {
		for(int i = 0; i < NUMERO_LETRAS; i++) {
			runnables[i] = new HiloLetra((char)(i+'A'), i+1, buffer);
			//System.out.println("creado hilo "+(char)(i+'A')+", num veces: "+(i+1));
			hilosLetras[i] = new Thread(runnables[i]);
		}
	}
 
	private void iniciarHilos() {
		for(int i = 0; i < NUMERO_LETRAS; i++) {
			hilosLetras[i].start();
		}
	}
 
 
	public static void main(String[] args) {
		Principal principal = new Principal();
		principal.iniciarHilos();
	}
 
 
 
}

Buffer es la clase donde se guarda el array de semáforos, y cuya instancia es un recurso compartido por todos los hilos.

Como he dicho, la salida del programa es correcta. Pero mi duda radica en si la concurrencia de veras está bien gestionada. Porque, mientras se ejecuta el programa, el administrador de tareas indica que la CPU está al 100%, lo cual me hace pensar que no se estén gestionando bien los hilos.

Gracias de antemano y saludos.