[/// BancoCSP_skel.java
// Lars feat. Julio -- 2021
// esqueleto de código para JCSP
// (peticiones aplazadas)
 
package cc.banco;
 
import org.jcsp.lang.Alternative;
import org.jcsp.lang.AltingChannelInput;
import org.jcsp.lang.Any2OneChannel;
import org.jcsp.lang.CSProcess;
import org.jcsp.lang.Channel;
import org.jcsp.lang.Guard;
import org.jcsp.lang.One2OneChannel;
import org.jcsp.lang.ProcessManager;
 
// otras librerías: estructuras de datos, etc.
// 
// 
// 
// COMPLETAD
// 
// 
// 
// 
 
 
public class BancoCSP implements Banco, CSProcess {
 
    // canales: uno por operación
    // serán peticiones aplazadas
    private Any2OneChannel chIngresar;
    private Any2OneChannel chDisponible;
    private Any2OneChannel chTransferir;
    private Any2OneChannel chAlertar; 
 
    // clases para peticiones
    // regalamos una como ejemplo
    public class TransferirReq {
	// atributos (pueden ser públicos)
	String from;
	String to;
	int value;
	One2OneChannel resp;
 
	// constructor
	public TransferirReq(String from, String to, int value) {
	    this.from = from; this.to = to; this.value = value; this.resp = Channel.one2one();
	}
    }
 
    public class AlertarReq {
	// atributos (pueden ser públicos)
	// 
	// COMPLETAD
	// 
 
	// constructor
	//
	// COMPLETAD
	//
    }
 
    public class IngresarReq {
	// atributos (pueden ser públicos)
	// 
	// COMPLETAD
	// 
 
	// constructor
	// 
	// COMPLETAD
	// 
    }
 
    public class DisponibleReq {
	// atributos (pueden ser públicos)
	// 
	// COMPLETAD
 
	// constructor
	// 
	// COMPLETAD
	//
    }
 
    // constructor de BancoCSP
    public BancoCSP() {
	this.chIngresar = Channel.any2one();
	this.chAlertar = Channel.any2one();
	this.chDisponible = Channel.any2one();
	this.chTransferir = Channel.any2one();
	new ProcessManager(this).start();
    }
 
    // interfaz Banco
    /**
     * Un cajero pide que se ingrese una determinado valor v a una
     * cuenta c. Si la cuenta no existe, se crea.
     * @param c número de cuenta
     * @param v valor a ingresar
     */
    public void ingresar(String c, int v) {
	// comprobar PRE
	// COMPLETAD
	// crear petición
	// COMPLETAD
	// enviar petición
	// COMPLETAD
    }
 
    /**
     * Un ordenante pide que se transfiera un determinado valor v desde
     * una cuenta o a otra cuenta d.
     * @param o número de cuenta origen
     * @param d número de cuenta destino
     * @param v valor a transferir
     * @throws IllegalArgumentException si o y d son las mismas cuentas
     *
     */
    public void transferir(String o, String d, int v) {
	// comprobar PRE
	// COMPLETAD
	// crear petición
	// COMPLETAD
	// enviar petición
	// COMPLETAD
	// esperar confirmación
	// COMPLETAD
    }
 
    /**
     * Un consultor pide el saldo disponible de una cuenta c.
     * @param c número de la cuenta
     * @return saldo disponible en la cuenta id
     * @throws IllegalArgumentException si la cuenta c no existe
     */
    public int disponible(String c) {
	// crear petición
	// COMPLETAD
	// enviar petición
	// COMPLETAD
	// recibir respuesta del servidor
	// COMPLETAD
	// tratar resultado
	// 
	// COMPLETAD
	// 
	//
    }
 
    /**
     * Un avisador establece una alerta para la cuenta c. La operación
     * termina cuando el saldo de la cuenta c baja por debajo de m.
     * @param c número de la cuenta
     * @param m saldo mínimo
     * @throws IllegalArgumentException si la cuenta c no existe
     */
    public void alertar(String c, int v) {
	// crear petición 
	// COMPLETAD
	// enviar petición
	// COMPLETAD
	// tratar respuesta del servidor
	// 
	// COMPLETAD
    }
 
    // Código del servidor
    public void run() {
	// nombres simbólicos para las entradas
	final int INGRESAR   = 0;
	final int DISPONIBLE = 1;
	final int TRANSFERIR = 2;
	final int ALERTAR    = 3;
 
	// construimos la estructura para recepción alternativa
	final Guard[] guards = new AltingChannelInput[4];
	guards[INGRESAR]   = chIngresar.in();
	guards[DISPONIBLE] = chDisponible.in();
	guards[TRANSFERIR] = chTransferir.in();
	guards[ALERTAR]    = chAlertar.in();
	Alternative servicios = new Alternative(guards);
 
	// El estado del recurso debe ir en el servidor (aquí)
	// Reutilizar de la práctica de monitores
	// COMPLETAD
 
	// colecciones para peticiones aplazadas
	// reutilizar de monitores si es posible
	// 
	// COMPLETAD
	//
	// 
 
	// Bucle principal del servicio
	while(true) {
	    int servicio = servicios.fairSelect();
 
	    switch (servicio) {
	    case INGRESAR: {
		// recibir petición
		// COMPLETAR
		// realizar ingreso
		// 
		// 
		// 
		break;
	    }
	    case DISPONIBLE: {
		// recibir petición
		// COMPLETAD
		// responder
		// COMPLETAD
		//
		break;
	    }
	    case TRANSFERIR: {
		// recibir petición
		// COMPLETAD
		// encolar petición
		// (alternativamente, se puede comprobar CPRE y
		//  solo encolar si estrictamente necesario)
		// 
		//
		//  COMPLETAD
		//
		//
		break;
	    }
	    case ALERTAR: {
		// recibir petición
		// COMPLETAD
		// encolar petición
		// (alternativamente, se puede comprobar CPRE y
		//  solo encolar si estrictamente necesario) 
		//
		//
		// COMPLETAD
		//
		//
		break;
	    }
	    }// END SWITCH
 
	    // tratamiento de peticiones aplazadas
	    // en parte, reutilizar de monitores
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // COMPLETAD
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    // 
	    //
 
	    // no debemos volver al inicio del bucle
	    // de servicio mientras haya alguna
	    // petición pendiente que se pueda atender !!
	}// END BUCLE SERVICIO
    }// END run SERVIDOR
 
    // cualquier otro código auxiliar que necesitéis...
 
}
 
]
Este es el esqueleto que me ayudo a hacer mi profesor