Em um simulador de escalonador preciso fazer com que as instruções de cada processo seja executada de acordo com a quantidade dessas instruções. Desde já agradeço a ajuda

Programação Java
#1

Processador

package escalonador;

import enumConfig.EnumTipo;

public class Processador {

    public static void main(String[] args) throws InterruptedException {
        
        Escalonador escalonador = new Escalonador();
        Processo.escalonador = escalonador;
        Escalonador.qtdeProcesso = 4;

        Processo p1 = new Processo("NetBeans", EnumTipo.CPU, 4);
        Processo p2 = new Processo("QAcademico", EnumTipo.IO, 6);
        Processo p3 = new Processo("Familydoc", EnumTipo.CPU, 3);
        Processo p4 = new Processo("SOAE", EnumTipo.IO, 4);

        Escalonador.prontos.add(p1);
        Escalonador.prontos.add(p2);
        Escalonador.prontos.add(p3);
        Escalonador.prontos.add(p4);
        
        escalonador.escalonarProcesso();

        p1.start();
        p2.start();
        p3.start();
        p4.start();
        
        p1.join();
        p2.join();
        p3.join();
        p4.join();
        
        Escalonador.imprimeStatusListas();

    }
}

Processo

package escalonador;

import enumConfig.EnumEstado;
import enumConfig.EnumTipo;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Processo extends Thread {

    public int pc = 0;
    public String nome;
    public EnumEstado estado = EnumEstado.PRONTO;
    public EnumTipo tipo;
    public int qtdePc;
    public static Escalonador escalonador;

    public Processo(String nome, EnumTipo tipo, int qtdePc) {
        this.nome = nome;
        this.tipo = tipo;
        this.qtdePc = qtdePc;
    }

    @Override
    public void run() {        
        while (this.qtdePc > this.pc) {
            try {
                if (this.estado.equals(EnumEstado.EXECUTANDO)) {
                    this.pc++; /*aqui o simulador esta executando uma instrução por vez. O professor quer 
                                      que seja executado as instruções de acordo com a quantidade 
                                      de instruções que cada processo tem. Ex. um processo tem que executar 4 
                                      instruções, ele executa 2 e passa para os processos e depois 
                                      volta e executa as outras instruções.*/
                    this.sleep(50);
                    escalonador.escalonarProcesso();
                } else {
                    synchronized (this) {
                        wait();
                    }
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    @Override
    public String toString() {
        return this.nome + "(" + this.pc + "/"+this.qtdePc+")";
    }

}

Escalonador

package escalonador;

import enumConfig.EnumEstado;
import enumConfig.EnumTipo;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Escalonador {

    public static List<Processo> prontos = new ArrayList<>();
    public static List<Processo> bloqueados = new ArrayList<>();
    public static List<Processo> finalizados = new ArrayList<>();
    public static Processo executando;
    public static int qtdeProcesso;
    public static int qtdeEscalonamento = 0;

    public static void imprimeStatusListas() {
        System.out.println("--------------- ESCALONAMENTO "+qtdeEscalonamento+" ---------------");
        System.out.println("PRONTOS: " + prontos.size());
        for (Processo pronto : prontos) {
            System.out.print(" | " + pronto.toString());
        }
        System.out.println("\nBLOQUEADOS: " + bloqueados.size());
        for (Processo bloqueado : bloqueados) {
            System.out.print(" | " + bloqueado.toString());
        }
        System.out.println("\nFINALIZADOS: " + finalizados.size());
        for (Processo finalizado : finalizados) {
            System.out.print(" | " + finalizado.toString());
        }
        if (executando != null) {
            System.out.println("\nEXECUTANDO: " + executando.toString());
        }else{
           System.out.println("\nEXECUTANDO: null"); 
        }
        System.out.println("\n");
    }

    public static void bloqueadoToPronto() {        
            Processo p = bloqueados.get(0);
            p.estado = EnumEstado.PRONTO;            
            prontos.add(p);
            bloqueados.remove(0);
    }

    public static void executandoToBloqueado() {
        executando.estado = EnumEstado.BLOQUEADO;
        bloqueados.add(executando);
    }

    public static void prontoToExetucando() {
        executando = prontos.get(0);
        executando.estado = EnumEstado.EXECUTANDO;
        prontos.remove(prontos.get(0));
    }

    public static void executandoToPronto() {
        executando.estado = EnumEstado.PRONTO;
        prontos.add(executando);
    }

    public static void executandoToFinalizado() {
        executando.estado = EnumEstado.FINALIZADO;
        finalizados.add(executando);
    }

    public synchronized void escalonarProcesso() {
        if (this.executando != null) {
            if (executando.pc >= executando.qtdePc) {
                executandoToFinalizado();
            } else if (executando.tipo.equals(EnumTipo.CPU)) {
                this.executandoToPronto();
            } else {
                this.executandoToBloqueado();
            }
        }

        // Zerando o executando
        executando = null;

        // Restaurando bloqueados
        while (bloqueados.size() > 0) {
            bloqueadoToPronto();
        }

        if (prontos.size() > 0) {
            prontoToExetucando();
            qtdeEscalonamento++;
            imprimeStatusListas();
            try {
                synchronized (executando) {
                    executando.notifyAll();
                }
            } catch (Exception e) {
            }
        }
    }
}

EnumTipo

package enumConfig;

public enum EnumTipo {    
    CPU, IO;    
}

EnumEstado

package enumConfig;

public enum EnumEstado {
    EXECUTANDO, PRONTO, BLOQUEADO, FINALIZADO;    
}
#2

E a pergunta? Dúvida? Problema? Erro?

#3

O simulador esta executando uma instrução por vez. O professor quer que seja executado as instruções de acordo com a quantidade de instruções que cada processo tem. Ex. um processo tem que executar 4 instruções, ele executa 2 cada vez que ele vai para o processador e passa para os outros processos e depois volta e executa as outras instruções.

#4

Eu nunca trabalhei com sistemas multithread. Porém, me parece que a solução seria você manter algumas coisas como synchronized