Quais são alguns exemplos simples e bons para filas? [fechadas]

Estou ensinando CS2 ( Java and data structures) e estou tendo dificuldades para encontrar bons exemplos para usar ao ensinar filas. As duas principais aplicações para as quais eu as uso são a multithreadedpassagem de mensagens (mas a programação do MT está fora do escopo do curso) e BFS-style algorithms(e eu não estarei cobrindo gráficos até mais tarde no termo).

Eu também quero evitar exemplos planejados. A maioria das coisas em que penso, se eu realmente as resolvesse de um modo de thread único, usaria apenas uma lista em vez de uma fila. Eu costumo usar filas apenas quando o processamento e a descoberta são intercalados (por exemplo, pesquisa) ou em outros casos especiais, como buffers de comprimento limitado (por exemplo, mantendo os últimos N itens). Na medida do possível, estou tentando ensinar aos meus alunos boas maneiras de realmente fazer coisas em programas reais, não apenas brinquedos para exibir um recurso.

Alguma sugestão de bons algoritmos simples ou aplicativos de filas que eu possa usar como exemplos, mas que exijam um mínimo de outro conhecimento prévio?

Quando eu estava aprendendo filas, meu professor sempre usava o exemplo de uma loja. Existem 1 ou mais registros abertos a qualquer momento, e os Clientes entram em uma fila ou outra e passam por essa fila para comprar todos os itens.

Na verdade, tivemos que implementar um programa simples que pudesse mover os Clientes por meio de um RegisterQueue; portanto, se você estiver procurando por um programa, poderá dar aos alunos que este exemplo é simples e direto, mas também algo que todos os alunos viram na vida real e, portanto, isso pode ajudá-los a entender melhor o conceito.

Quando aprendi as filas, meu professor as apresentou usando uma fila de carros no controle da polícia. Havia uma fila segurando os carros ("fila de espera") e o policial sempre controlava o próximo carro na fila e o enviava ao colega para mais inspeções ou deixava o carro passar.

Um exemplo usado com muita frequência é a fila no super mercado ...

Por que você não pede a seus alunos que dêem alguns exemplos?

Um exemplo que me vem à mente é uma linha de processamento de hambúrgueres, por exemplo, no McDonalds. Existem vários tipos de hambúrgueres diferentes, cada um pode ser produzido por vários trabalhadores diferentes e cada um tem sua própria fila. A partir daí, depois de um tempo, os hambúrgueres prontos são levados, na ordem FIFO, por um dos caixas que encomendaram esse tipo de hambúrguer.

Portanto, existem vários produtores e consumidores e cada fila é limitada.

Pensei em usar a Amazon como exemplo, em algum lugar em seu sistema maciço deve haver uma fila de pedidos que precisa ser tratada. que poderia ser tratado por uma fila simples e desenfileirada. o sistema enfileirava um pedido no sistema toda vez que um cliente comprava um livro, e uma pessoa do depósito o desenfileirava para buscá-lo e publicá-lo.

Seria fácil começar a falar sobre filas prioritárias, apresentando clientes principais, que poderiam pular a fila e introduzir filas prioritárias.

Que livro você está usando?

Um exemplo perfeito de uma fila seria um banco processando transações em uma conta. Normalmente, você verá uma lista de transações "pendentes" no final do dia. Quando a contabilidade é concluída, essas transações são aplicadas à conta. Você pode até entrar na área de filas prioritárias com isso. Parece que a maioria dos bancos prioriza os débitos ao processar transações noturnas, para que você possa pagar mais do que as taxas de saque antes de aplicar qualquer crédito pendente.

As transações são inseridas na fila por ordem de tempo executadas e desenfileiradas e aplicadas à conta pelo processo contábil.

Eu costumava ser um programador de telecomunicações, então isso me vem à mente:

Uma linha direta de atendimento ao cliente. Uma chamada chega, não há operadores suficientes para lidar com a chamada e ela é colocada em uma fila. A próxima chamada é recebida e também é colocada na fila. Então, quando o próximo operador ficar disponível, a primeira chamada que entrou na fila será atribuída ao operador disponível.

Os exemplos óbvios do mundo real seriam coisas como linhas de checkout e assim por diante, mas como você está procurando um exemplo estritamente baseado na computação, posso sugerir filas de agendamento de tarefas ?

Não sei quantos de seus alunos fizeram uma aula de sistemas operacionais, mas é uma boa aposta que todos eles tenham usado o Gerenciador de tarefas para verificar seus processos em algum momento ou outro. Você pode introduzir um exemplo simplificado de uma fila de agendamento e atribuir a eles algum trabalho de casa para escrever um programa que gere (ou aceite) uma "tarefa" de um determinado tamanho e os processe na ordem FIFO quando a "iniciar".

É um conceito bastante fácil de entender, demonstra a idéia de que a fila opera em seu conteúdo na ordem em que os aceita e fornece uma introdução (muito rudimentar e simplificada) ao agendamento da CPU. Apenas meus dois bits.

Você pode abrir o aplicativo deles em multithreading, mas, a menos que os alunos já tenham alguma experiência em escrever programas encadeados, eu não atribuiria um trabalho a eles que pode ser frustrante. Lembro que tive problemas para aprender estruturas de dados (especialmente em Java, não tendo feito C ++ e não aprendido nada sobre ponteiros) no meu segundo ano de faculdade, então um exemplo simples, mas prático, diretamente relacionado à computação é provavelmente o melhor.

Mundo real:

• Sempre que as pessoas se alinham: caixa no supermercado, no restaurante à espera de uma mesa (você pode trabalhar naqueles bipes que às vezes emitem na analogia), etc. É útil quando você percebe que no Reino Unido eles costumam chame essas filas em vez de linhas (comum em NA)
• Leitura de séries de livros ', author.publish => fila.push e student.read => fila.pop

Mundo Não Real:

• Processando todos os dados enviados em um ambiente de thread único, em que o processamento demora mais que o envio (operações de checkout para lojas on-line, por exemplo).
• Qualquer coleção FIFO que possa ser iterada pode usar filas e usar em while(queue.peek)vez de um iterador.

Eu gosto de usar jogos como exemplo, porque geralmente é um pouco mais emocionante do que o arquivo IO ou qualquer outra coisa que você possa criar.

Portanto, quando você deseja emitir vários comandos seguidos para uma unidade em um jogo de estratégia (por exemplo, faça um Zergling explorar 4 cantos de uma base em ordem e, em seguida, se suicide no centro da base, uma fila seria uma boa escolha .)

Ou talvez você tenha um aplicativo que só pode processar 30 quadros por segundo, mas você pode obter 4 ou 5 entradas entre os quadros. Se você tem uma entrada de troca de arma e uma entrada de tiro, deseja garantir que elas sejam manuseadas na ordem em que foram recebidas, caso contrário, você poderá granar quando quiser faca. E se você fizer uma granada quando quiser faca, terá um mau momento. (coloque isso no meme do instrutor de esqui e jogue nos slides) :)

Um servidor que manipula solicitações é outro bom.

Uma máquina CNC recebendo entrada. A máquina só pode ir tão rápido, por isso precisa enfileirar as entradas.

Alguns exemplos em que posso pensar:

• Calculadora - pode introduzir prefixo e postfix ao mesmo tempo
• Instruções para amarrar sapatos. Não é possível concluir a próxima operação até que você tenha feito a última
• Buffers - Talvez um buffer de telefone usado para armazenar números que o usuário digitou, mas ainda não emitiu o tom.
• Digestão

As linhas de fabricação estão cheias de filas. Pense em uma linha de garrafas vazias em direção a uma máquina de envase. O primeiro a entrar é o modo natural de aplicar um processo sequencialmente a muitos objetos. As filas também são usadas para separar um processo de outro: a máquina de envase não precisa parar imediatamente se houver um problema de curto prazo com a etiquetadora.

As filas são usadas no software da mesma maneira. A saída de um processo pode ser enfileirada para entrada em outro processo. Isso é verdade se você está falando sobre comunicação entre processos, comunicação entre threads ou simplesmente dividindo um processo complicado em partes que podem ser tratadas pelo mesmo thread.

Nos sistemas operacionais, as filas são frequentemente usadas para processar entradas em ordem. O sistema de arquivos pode ler blocos de um dispositivo de armazenamento e adicioná-los a uma fila, por exemplo. Ou interrupções que manipulam coisas como pressionamentos de tecla e movimentos do mouse criam eventos que são adicionados a uma fila de eventos para que você não obtenha "uqeeu" em vez de "fila" ao digitar.

Para uma tarefa simples para os alunos, acho que qualquer tarefa que aceite algum número de entradas e depois as processe funcionaria. Por exemplo, você pode fazer com que eles escrevam um avaliador de expressão postfix simples. Teria três partes:

• leia uma entrada, adicione-a à fila de entrada e repita até que não haja mais entradas

• obter um item da fila

  • se o item for um número, empurre-o para a pilha de argumentos
  • se o item for um operador, exiba os argumentos necessários e avalie
  • adicione o resultado à fila de saída
  • repita até a pilha ficar vazia

• leia um item da fila de saída, imprima-o e repita até que a fila de saída esteja vazia

No ensino de estruturas de dados, geralmente uso o aplicativo da simulação de fila bancária, onde os clientes esperam em uma fila e há várias janelas de serviço.

O problema é simular o processo para descobrir estatísticas do seguinte: tempo de espera dos clientes na fila (máximo, mínimo, média) e número de clientes que aguardam na fila. Uso uma frequência predefinida de chegada de novos clientes a cada minuto do dia e um tempo médio de serviço de um cliente na janela de serviço com valores do gerador de números aleatórios.

O resultado serão recomendações para o número ideal de janelas de serviço e o número ideal de cadeiras na sala de espera que garantiriam a satisfação do cliente. Aplicação muito interessante para os alunos.

Qualquer algoritmo de agendamento quase sempre envolve uma fila.

Isso pode variar de uma fila simples primeiro a chegar, primeiro a ser atendida, até a solicitação de buffer para um único consumidor.

Para uma fila complexa de agendamento de tarefas em que "tarefas" podem ter prioridades e "trabalhadores" têm recursos diferentes.

Um bom caso de uso para brincar pode ser "Você tem um servidor de impressão central com quatro impressoras conectadas, duas capazes de cores, uma capaz de imprimir em frente e verso e outra em papel maior. Os usuários podem pagar mais por um trabalho urgente, ou menos, se não se importarem em esperar mais. Você poderá sofrer penalidades se entregar com atraso, de modo a obter o máximo rendimento possível ".