A interface da fila está no mesmo nível que a lista e o conjunto, e ambos herdam a interface de coleta. O LinkedList implementa a interface da fila. A interface da fila restringe o acesso ao método LinkedList (ou seja, se o tipo de parâmetro no método for uma fila, ele só poderá acessar os métodos definidos pela interface da fila e não pode acessar diretamente os métodos que não são os que não o queriam da lista vinculada), para que apenas o método apropriado possa ser usado. BlockingQuee herda a interface da fila.
Uma fila é uma estrutura de dados. Possui duas operações básicas: adicionar um elemento no final da fila e remover um elemento da cabeça da fila significa que a fila gerencia os dados de uma maneira de primeira linha. Se você tentar adicionar um elemento a uma fila de bloqueio completa ou remover um metasector de uma fila de bloqueio vazia, ele fará com que o thread bloqueie. Bloquear filas é uma ferramenta útil ao cooperar com vários threads. Os threads de trabalhadores podem armazenar regularmente resultados intermediários em uma fila de bloqueio, enquanto outros threads de trabalhadores retiram resultados intermediários e os modificam no futuro. A fila equilibra automaticamente a carga. Se o primeiro conjunto de thread funcionar mais lento que o segundo, o segundo conjunto de threads bloqueará enquanto aguarda o resultado. Se o primeiro conjunto de threads funcionar rapidamente, ele aguardará o segundo conjunto de thread para se atualizar. A tabela a seguir mostra as operações de bloqueio de filas no JDK1.5:
Adicionar adicione uma meta -pesquisa se a fila estiver cheia, jogue uma exceção iiiegaislabeePeplian
Remova remova e retorne o elemento na cabeça da fila. Se a fila estiver vazia, uma exceção de NosuchElementException será lançada.
O elemento retorna o elemento na cabeça da fila. Se a fila estiver vazia, uma exceção de NosuchElementException será lançada.
Oferta Adicione um elemento e retorna true se a fila estiver cheia, retorne falsa
A pesquisa remove e devolve o elemento na cabeça da fila. Se a fila estiver vazia, retorne nulo.
Peek devolve o elemento à frente da fila. Se a fila estiver vazia, retorne nulo
coloque adicione um elemento se a fila estiver cheia, bloqueando
Retire e devolva o elemento na cabeça da fila. Se a fila estiver vazia, blocos
Remover, elemento, oferta, pesquisa e Peek realmente pertencem à interface da fila.
As operações que bloqueiam as filas podem ser divididas nas três categorias a seguir, de acordo com suas respostas: as operações de AAD, Remover e elementos lançam exceções ao tentar adicionar elementos a uma fila completa ou obter elementos de uma fila vazia. Obviamente, em um programa multithread, a fila pode ficar cheia ou vazia a qualquer momento; portanto, você pode usar os métodos de oferta, pesquisa, Peek. Esses métodos simplesmente fornecem uma mensagem de erro quando a tarefa não pode ser concluída sem lançar uma exceção.
NOTA: Métodos de enquete e Peek erros e retorne nulos. Portanto, é ilegal inserir um valor nulo na fila.
Também existem variantes de métodos de oferta e pesquisa com tempos limite, por exemplo, as seguintes chamadas:
sucesso booleano = q.offer (x, 100, timeUnit.millisEconds);
Tente inserir um elemento na cauda da fila em 100 milissegundos. Se for bem -sucedido, retorne verdadeiro imediatamente; Caso contrário, quando o tempo limite for atingido, retorne FALSE. Da mesma forma, ligue:
Cabeça de objeto = q.poll (100, timeUnit.millisEconds);
Se o elemento de cabeçalho da fila for removido com sucesso em 100 milissegundos, o elemento de cabeçalho será retornado imediatamente; Caso contrário, o NULL é devolvido quando o tempo limite é atingido.
Finalmente, temos operações de bloqueio colocadas e tomadas. O método put bloqueia quando a fila está cheia e o método de Take bloqueia quando a fila está vazia.
O pacote java.ulil.Concurrent fornece 4 variantes de filas de bloqueio. Por padrão, a capacidade do LinkedBlockingQueue não é limite superior (é impreciso. A capacidade é inteira.max_value quando não especificada. Se não, como pode ser bloqueado quando colocado), mas você também pode optar por especificar sua capacidade máxima. É uma fila baseada em uma lista vinculada, que classifica os elementos do FIFO (primeiro na primeira saída).
O ArrayBlockockQueue precisa especificar a capacidade durante a construção e você pode escolher se é necessária a justiça. Se o parâmetro justo for definido, o thread com o tempo de espera mais longo será processado primeiro (de fato, essa justiça é alcançada definindo o ReentrantLock como True: isto é, o thread com o tempo de espera mais longo funcionará primeiro). Normalmente, a justiça pode custar -lhe desempenho e usá -lo apenas quando é realmente necessário. É uma fila de loop de bloqueio baseada em matriz que classifica os elementos de acordo com o princípio do FIFO (primeiro na primeira saída).
O PriorityBlockingQueue é uma fila com prioridade, não uma fila da primeira vez na primeira saída. Os elementos são removidos em ordem prioritária e a fila não tem limite superior (olhei para o código-fonte. O priorityBlockQueue é um reescrita do priorityQueue, que é baseado na estrutura de dados do heap. O prioridade não tem um limite de capacidade, assim como o que pode ser o que pode ser o que pode ser o que pode ser bloqueado por um prioridade. OutOfMemoryError por causa do recurso estar esgotado), mas se a fila estiver vazia, a operação do elemento será bloqueada, para que sua operação de pesquisa seja bloqueada. Além disso, os elementos que entram na fila devem ter recursos comparativos.
Finalmente, o atraso (implementado com base no PriorityQueue) é uma fila de bloqueio ilimitada que armazena elementos atrasados, e os elementos só podem ser extraídos quando o atraso expirar. A cabeça desta fila é o elemento atrasado, com o tempo de armazenamento mais longo após o término do atraso. Se nenhum dos atrasos expirou, a fila não tem cabeçalhos e a pesquisa retornará nulo. Quando o método getDelay (timeUnit.nosegunds) de um elemento retorna um valor menor ou igual a zero, a expiração ocorre e a pesquisa remove o elemento. Esta fila não permite elementos nulos. Aqui está a interface de atraso:
Código Java
interface pública atrasada estende comparável a <oulded> {long getDelay (unidade TimeUnit); }O elemento que coloca o DeLeCeue também implementará o método compareto, que usa isso para classificar os elementos.
O exemplo a seguir mostra como usar uma fila de bloqueio para controlar um conjunto de threads. O programa procura todos os arquivos em um diretório e todas as suas subdiretas e imprime uma lista de arquivos que contêm as palavras -chave especificadas. Como pode ser visto nos exemplos a seguir, os dois benefícios significativos do uso de filas de bloqueio são: operação multithread de filas comuns não requer sincronização adicional. Além disso, a fila equilibrará automaticamente a carga, ou seja, se o processamento (ambos os lados da produção e consumo) for processado rapidamente, ela será bloqueada, reduzindo assim a lacuna de velocidade de processamento entre os dois lados. A seguir, a implementação específica:
Código Java
classe pública BlockingQueuEtest {public static void main (string [] args) {scanner in = new scanner (system.in); System.out.print ("Digite o diretório base (por exemplo, /usr/local/jdk5.0/src):"); Diretório de string = in.NextLine (); System.out.print ("Digite a palavra -chave (por exemplo, volátil):"); String Keyword = in.NextLine (); final int file_queue_size = 10; // bloqueando o tamanho da fila final int search_threads = 100; // Número de threads de pesquisa de palavras -chave // bloqueando a fila com base no ArrayBlockingQueuClockingQueue <File> Queue = new ArrayBlockQueue <File> (fileuue_size); // inicia apenas um thread para pesquisar no diretório FileEnumationTask Enumerator = new FileEnumationTask (fila, novo arquivo (diretório)); novo thread (enumerador) .start (); // Inicie 100 threads para pesquisar a palavra -chave especificada no arquivo para (int i = 1; i <= search_threads; i ++) novo thread (new SearchTask (fila, palavra -chave)). Start (); }} classe FileEnumationTask implementa Runnable {// O objeto de metafile idiota é colocado no final da fila de bloqueio para indicar que o arquivo foi perseguido o arquivo estático público = novo arquivo (""); Fila de BlockingQueue privada <File>; arquivo privado inicialDDirectory; public fileEnumemationTask (BlockingQueue <File> Fila, FILE STEINDDirectory) {this.queue = fila; this.startingDirectory = StartDDirectory; } public void run () {try {enumerate (StartingDirectory); fileue.put (dummy); // Execute aqui para indicar que o arquivo no diretório especificado foi atravessado} catch (interruptEdException e) {}} // Coloque todos os arquivos no diretório especificado na fila de bloqueio; para (arquivo de arquivo: arquivos) {if (file.isdirectory ()) enumerar (file); else // Coloque o elemento no final da fila. Se a fila estiver cheia, bloqueie a fila.put (arquivo); }}} classe SearchTask implementa Runnable {Private BlockingQueue <File> fila; palavra -chave privada string; public SearchTask (BlockingQueue <File> Fila, String Keyword) {this.queue = fila; this.keyword = palavra -chave; } public void run () {try {boolean done = false; while (! feito) {// busca o primeiro elemento da fila. Se a fila estiver vazia, o arquivo de bloco = fila.take (); if (file == FileEnumationTask.Dummy) {// buscá -lo e coloque -o para que outros threads terminem rapidamente ao lê -lo na fila.put (arquivo); feito = true; } else Search (arquivo); }} catch (ioexception e) {e.printStackTrace (); } catch (interruptedException e) {}} public void search (arquivo de arquivo) lança ioexception {scanner in = new scanner (new FileInputStream (file)); int linenumber = 0; while (in.hasNextLine ()) {linenumber ++; Linha de string = in.NextLine (); if (line.contains (palavra -chave)) system.out.printf ("%s:%d:%s%n", file.getpath (), linenumber, linha); } in.close (); }} Link original: http://www.cnblogs.com/end/archive/2012/10/25/2738493.html
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.