Ejemplo n.º 1
0
        //método que muda a interface de tempos em tempos
        private void AtualizaInterface()
        {
            while (!GerenciadorDeProcessos.FilaDeProcessosVazia(FilaProcessos)) //Enquanto houver processos a serem executados
            {
                try
                {
                    Dispatcher.Invoke(
                        new Action(() =>
                    {
                        nThreadExibindo = ComboBoxThreadExibicao.SelectedIndex;
                    }));

                    AtualizarValores(nThreadExibindo); //Tabela é atualizada
                    Thread.Sleep(tempoInterface);      //Thread dorme por tempo determinado pelo usuario
                }

                catch (TaskCanceledException) //exceção disparada quando tentam finalizar o programa antes das tarefas serem concluidas
                {
                    return;                   //finaliza a thread
                }
            }

            Dispatcher.Invoke(
                new Action(() =>
            {
                DataGridGerenciador.Items.Clear(); //Limpa a tela para remover os processos que restaram no DataGrid
                MessageBox.Show("Todos os processos foram concluídos ", TotalProcessosConcluidos().ToString(), MessageBoxButton.OK, MessageBoxImage.Information);
                AtualizarControles(true);          //libera e limpa todos os controles

                LabelNomeProcesso.Content = "";
                LabelPID.Content          = "";
                LabelPrioridade.Content   = "";
                LabelTempoExec.Content    = "";

                InterromperThreads();
            }));
        }
Ejemplo n.º 2
0
        //Evento de click do botão de iniciar a simulação
        private void BtnIniciaSimulacao_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                //captura os valores dados pelo usuario
                int q       = int.Parse(TxtQuantum.Text);
                int threads = (Convert.ToInt32(ComboBoxNumeroThreads.SelectedIndex + 1)); //número de threads
                tempoInterface = int.Parse(TxtTempoInterface.Text);                       //tempo de atualização da interface
                int tempoVerificacao = int.Parse(TxtTempoVerif.Text);                     //tempo de verificação de execução
                int tempoEspera      = int.Parse(TxtTempoEspera.Text);                    //tempo máximo de espera antes de subir a prioridade
                totalProcesso = 0;

                //Tratamento de erros
                if (q <= 0)
                {
                    MessageBox.Show("Quantum inválido. O tempo deve ser superior a 0.");
                }

                else if (tempoInterface <= 0)
                {
                    MessageBox.Show("Tempo de atualização de interface inválido. O tempo deve ser superior a 0.");
                }

                else if (tempoVerificacao <= 0)
                {
                    MessageBox.Show("Tempo de verificação de prioridades inválido. O tempo deve ser superior a 0.");
                }

                else if (threads <= 0)
                {
                    MessageBox.Show("Indique um número de threads.");
                }


                //bloco executado quando não há erros
                else //sem erros de números inferiores a 0
                {
                    //declarando tamanho dos vetores de threads e gerenciadores de processos
                    gerenciadorDeProcessos = new GerenciadorDeProcessos[threads];
                    ThreadDeExecucao       = new Thread[threads];

                    //preenche as filas com os processos necessários
                    produtor.PreencherFilaDeProcessos(FilaProcessos);

                    //loop para descobrir quantos processos necessitam de serem executados
                    foreach (FilaDeProcessos fila in FilaProcessos)
                    {
                        totalProcesso += fila.ContadorDeProcesso;
                    }

                    //instanciando todos os gerenciadores de processo
                    for (int ax = 0; ax < threads; ax++)
                    {
                        gerenciadorDeProcessos[ax] = new GerenciadorDeProcessos(q, tempoVerificacao);
                    }

                    int a = 0;

                    //inicia as threads de execução
                    foreach (GerenciadorDeProcessos g in gerenciadorDeProcessos)
                    {
                        ThreadDeExecucao[a] = new Thread(() => g.ExecutarProcesso(FilaProcessos));
                        ThreadDeExecucao[a].Start();
                        a++;
                    }

                    ControlePrioridadeEspera = new Thread(() => GerenciadorDeProcessos.ControlePrioridadeEspera(FilaProcessos, tempoEspera));
                    ControlePrioridadeEspera.Start();

                    ThreadInterface = new Thread(AtualizaInterface);

                    //Adiciona items no ComboBox de Threads, de acordo com o numero de Threads que o usuario solicitar
                    for (int ab = 0; ab < threads; ab++)
                    {
                        ComboBoxThreadExibicao.Items.Add(ab + 1);
                    }

                    ComboBoxThreadExibicao.SelectedIndex = 0;
                    ThreadInterface.Start();
                    AtualizarControles(false);
                }
            }

            catch (FormatException ex)
            {
                MessageBox.Show(ex.Message);
            }
        }