/** 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[])
Ejemplo n.º 3
0
  /** 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));
   }
 }