/** Loop principal Gera pedidos aleat�rios para fornecedores aleat�rios */
public void run() {
Pedido pedido = new Pedido();
for (; ; ) {
try {
Thread.sleep(Projeto2.randInt(500));
} catch (InterruptedException e) {
Projeto2.setVerbose(true);
Projeto2.debug("interrompido enquanto dormia");
return;
}
for (Cana g : Cana.values()) {
pedido.set(g, Projeto2.randInt(1, 10));
}
Cana g = Cana.randChoice();
Projeto2.debug("solicitando %s ao atravessador de cana %s", pedido, g);
try {
Projeto2.especialista(g).get(pedido);
} catch (InterruptedException e) {
Projeto2.setVerbose(true);
Projeto2.debug(
"interrompido durante solicita��o%n" + " %s do fornecedor de cana %s", pedido, g);
return;
}
Projeto2.debug("recebi %s do fornecedor de cana %s", pedido, g);
consome(pedido);
}
} // run()
/**
* Programa principal para o projeto 2.
*
* @param args argumentos da linha de comando.
*/
public static void main(String[] args) {
// Faz o parsing dos argumentos da linha de comando.
GetOpt options = new GetOpt("Projeto2", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
usage();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 2) {
usage();
}
alambiqueCount = Integer.parseInt(args[options.optind]);
int iteracoes = Integer.parseInt(args[options.optind + 1]);
// Cria os atravessadores
atravessadores = new EnumMap<Cana, Atravessador>(Cana.class);
for (Cana g : Cana.values()) {
// Voc� precisa implementar a classe AtravessadorImpl para o programa funcionar.
atravessadores.put(g, new AtravessadorImpl(g));
}
// Criar o �nico fornecedor.
fornecedor = new Fornecedor(iteracoes);
Thread threadFornecedor = new Thread(fornecedor, "Fornecedor");
alambiques = new Alambique[alambiqueCount];
alambiqueThreads = new Thread[alambiqueCount];
for (int i = 0; i < alambiqueCount; i++) {
alambiques[i] = new Alambique();
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique " + i);
}
// Inicia os threads
// Todos eles tem prioridade mais baixa que o thread pricniapl ent�o nenhum deles
// come�ar� a rodar antes que todos tenham sidos inicializados.
threadFornecedor.setPriority(Thread.NORM_PRIORITY - 1);
threadFornecedor.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera que todos os threads sejam finalizados
try {
// O thread do fornecedor ser� finalizado quando ele concluir todas as itera��es
// especificadas.
threadFornecedor.join();
// Espera 3 segundos para dar uma chance para os threads do alambique terminarem
// depois disso, todos que n�o finalizarem ser�o interrompidos.
Thread.sleep(3000);
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Finalizando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int nosAtravessadores = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, n);
produzido += n;
}
for (Cana g : Cana.values()) {
quant = atravessadores.get(g).getEstoqueDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
nosAtravessadores += n;
}
}
for (int i = 0; i < alambiqueCount; i++) {
quant = alambiques[i].getConsumo();
out.printf("O Alambique %d consumiu %s%n", i, quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
}
out.printf("O balan�o final � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d,"
+ " sobrando nos atravessadores = %d, liquido = %d%n",
produzido, consumido, nosAtravessadores, (produzido - consumido - nosAtravessadores));
} // main(String[])
/** M�todo principal */
public static void main(String[] args) {
// faz o parsing dos argumentos da linha de comnaod
GetOpt options = new GetOpt("Projeto3", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
uso();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 3) {
uso();
}
int algoritmo = Integer.parseInt(args[options.optind + 0]);
alambiqueN = Integer.parseInt(args[options.optind + 1]);
int iteracoes = Integer.parseInt(args[options.optind + 2]);
// Cria o dep�sito
deposito = new Deposito(algoritmo);
Thread dthread = new Thread(deposito, "Deposito");
// Cria o fornecedor
fornecedor = new Fornecedor(iteracoes);
Thread fThread = new Thread(fornecedor, "Fornecedor");
// Cria os alambiques
alambiques = new Alambique[alambiqueN];
alambiqueThreads = new Thread[alambiqueN];
for (int i = 0; i < alambiqueN; i++) {
alambiques[i] = new Alambique(i);
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique" + i);
}
// Inicia os threads
dthread.setPriority(Thread.NORM_PRIORITY - 1);
dthread.start();
fThread.setPriority(Thread.NORM_PRIORITY - 1);
fThread.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera at� que todos os threads sejam encerrados
try {
// O thread do fornecedor se encerra quando ele completa todas as itera��es
fThread.join();
// Aguarda 3 segundos para dar chance a todos de terminarem o que est�o fazendo,
// em seguida todos s�o interrompidos
Thread.sleep(3000);
// Mata o thread do dep�sito
dthread.interrupt();
dthread.join();
// Mata os alambiques
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Programa terminando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int noDeposito = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
balanco.troca(quant);
produzido += quant.total();
quant = deposito.getDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
noDeposito += n;
}
Pedido totalConsumido = new Pedido();
int totalRequisitado = 0;
int totalEspera = 0;
for (int i = 0; i < alambiqueN; i++) {
quant = alambiques[i].getConsumo();
int requisitado = alambiques[i].requisicoesConcluidas();
int espera = alambiques[i].tempoDeEspera();
totalConsumido.troca(quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
out.printf("Alabique %d%n", i);
out.printf(" Cana consumida: %s%n", quant);
out.printf(" Requisi��es atendidas: %d%n", requisitado);
out.printf(" Tempo total de espera: %d ms%n", espera);
if (requisitado > 0) {
out.printf(" Tempo de espera m�dio: %.2f ms%n", espera / (double) requisitado);
}
totalRequisitado += requisitado;
totalEspera += espera;
}
out.printf("Balan�o (deficit) � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d," + " restando no dep�sito = %d, l�quido = %d%n",
produzido, consumido, noDeposito, (produzido - consumido - noDeposito));
out.printf(
"Requisi��es conclu�das: %d, tempo de espera m�dio %.2fms%n",
totalRequisitado, totalEspera / (double) totalRequisitado);
}
/**
* Consome o total indicado de cana de a��car
*
* @param um vetor de resultados, um para cada tipo de cana.
*/
private synchronized void consome(Pedido pedido) {
for (Cana g : Cana.values()) {
consumido.troca(g, pedido.get(g));
}
}