https://www.raywenderlich.com/5370-grand-central-dispatch-tutorial-for-swift-4-part-1-2

esta é a continuação da simultaneidade na série swift. Ver parte1 e parte 2 para entender o básico

nesta parte abordaremos tópicos a seguir

  1. o Que é a Operações e a Vida de estados
  2. Criar Bloco, NSInvocationOperation , e Operações Personalizadas para executar tarefas assíncronas
  3. Como cancelar as operações
  4. o Que é a Operação de Filas
  5. Como adicionar Operações Em Operação Filas
  6. Como criar dependências entre as Operações
  7. Benefícios de Operação Filas de Mais de GCD
  8. Despacho Grupo Usando a Implementação da Operação de Filas

as Operações são um maneira orientada a objetos de encapsular o trabalho que você deseja executar de forma assíncrona. As operações são projetadas para serem usadas em conjunto com uma fila de operação ou por si mesmas

um objeto de operação é uma instância da classe Operation or NSOperation (no framework Foundation) que você usa para encapsular o trabalho que deseja que seu aplicativo execute.

a classe Operation em si é uma classe base abstrata que deve ser subclassificada para fazer qualquer trabalho útil. Apesar de ser abstrato, esta classe fornece uma quantidade significativa de infraestrutura para minimizar a quantidade de trabalho que você precisa fazer em suas próprias subclasses. Além disso, o Foundation framework fornece duas subclasses concretas que você pode usar como está com seu código existente.

Estado de operações

uma operação possui uma máquina de Estado que representa seu ciclo de vida. Existem vários estados possíveis que ocorrem em várias partes deste ciclo de vida:

  • quando for instantiated, ele fará a transição para o estado isReady.
  • quando invocamos o método start, ele fará a transição para o estado isExecuting.
  • Quando a tarefa finished , move-se para isFinished
  • Quando a tarefa está em curso e chamar cancel , em seguida, ele fará a transição para a isCancelled estado antes de passar para o isFinished estado

Existem basicamente três maneiras de criar operações

BlockOperation (Classe Concreta)

Uma classe utiliza como está a executar um ou mais objectos do bloco simultaneamente. Como ele pode executar mais de um bloco, um objeto de operação de bloco opera usando um grupo semântico; somente quando todos os blocos associados tiverem concluído a execução, a própria operação será considerada concluída.. Na operação de bloco, você pode aproveitar as dependências de operação, KVO, notificações e cancelamento .

, Como mostrado na Figura 1 nós com a execução do presente código async o que significa que ele irá retornar imediatamente, mas a má notícia é que ele irá bloquear o thread principal desde operation.start() foi chamado thread principal

objetos de Operação executar de uma maneira síncrona por padrão, isto é, eles executam suas tarefas em que o thread que chama a sua start método.

Figura 1

o Que diabos é a maneira síncrona e executar um ou mais objectos do bloco simultaneamente.

, Como mostrado na Figura 1.0.1 como você pode ver as tarefas/blocos de adicionado ao Bloco de operação em si executadas simultaneamente, mas o bloco de executar maneira síncrona significa que bloqueou o segmento em que iniciar é chamado no nosso caso, é thread principal

Figura 1.0.1

Como mostrado na Figura Figura 1.0.2 , desde que de início da chamada de método em outra thread , ele irá bloquear o thread

Figura 1.0.2

Como mostrado na Figura Figura 1.0.3, podemos adicionar a conclusão do bloco, bem como que será chamada quando todos os concorrentes blocos será executado

Figura 1.0.3

Executar o Bloco de Operação Simultaneamente

, Como mostrado na Figura 1.1 como chamamos o método start() em um thread em segundo plano, ele executará sua tarefa no thread. Há uma maneira legal de fazer isso usando a fila de operação e veremos isso mais tarde.

Figura 1.1

NSInvocationOperation (Classe Concreta)

Uma classe pode utilizar como-é criar uma operação objeto com base em um objeto e seletor de sua aplicação.

no objective C, podemos criar NSInvocationOperation embora não esteja disponível no Swift.

https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html#//apple_ref/doc/uid/TP40008091-CH101-SW6

3. Operações personalizadas

subclasse Operation dá-lhe controle completo sobre a implementação de suas próprias operações, incluindo a capacidade de alterar a maneira padrão em que sua operação executa e relata seu status.

conforme mostrado na Figura 2, criamos operações personalizadas subclassificando-as da classe base Operation e substituindo seu método main. Quando você subclasse, você coloca sua tarefa no método main. Implementamos não concorrente operação personalizada e, neste caso, bloqueou a thread principal

Figura 2

Se você planeja executar operações manualmente e ainda quer que eles para executar de forma assíncrona, você deve tomar as medidas adequadas para garantir que eles fazem. Você faz isso definindo seu objeto de operação como uma operação simultânea.

conforme mostrado na Figura 3, realizamos as seguintes etapas para executar a tarefa simultaneamente

  1. subclasse criada MyConcurrentQueue . Digitacao: O nome deve ser MyConcurrentOperations
  2. Chamar start() método irá chamar main() método de thread de plano de fundo
  3. No método main definimos a nossa tarefa e uma coisa a notar que atendem cancelar caso, como bem
  4. Em chamar cancel em operação personalizada farão a transição para o isCancelled estado e quebrar o ciclo e, como mostrado na Figura 3, ele irá imprimir apenas 39487 itens

Figura 3

Operação de Filas

  1. Operações de Filas de Cacau de alto-nível de abstração no GCD
  2. Usando Filas de operação você verá o poder real das operações, em vez de iniciar a operação você mesmo , você dá-lo para a fila de operação em seguida, lidar com o agendamento e execução.
  3. as filas de operação são uma maneira orientada a objetos de encapsular o trabalho que você deseja executar de forma assíncrona.
  4. você adiciona operations (tarefas/trabalho) em operation queue e discutimos como podemos criar operações usando dois métodos.

Adicionar operações

conforme mostrado na Figura 4, criamos duas operações (usando bloco) e as adicionamos à fila de operação. A fila de operação iniciou ambas as operações em algum thread em segundo plano e as executou. Não há necessidade de chamar o método start() no thread personalizado 🆒. Quando nós operação de adicionar à fila de operações é executada assim que ele está pronto

Figura 4

Como mostrado na Figura 5 vemos apenas a tarefa executada em série ou pode-se dizer que implementado série de fila usando a Operação de Filas por favor, consulte a minha parte 1 se você não sabe o que é série fila de configuração maxConcurrentOperationCount = 1

maxConcurrentOperationCount →O número máximo de operações em fila que podem ser executadas ao mesmo tempo. O valor padrão é -1, o que significa que o sistema de decidir

Figura 5

Pela definição de maxConcurrentOperationCount = 2 fizemos uma simultâneas fila e agora são as tarefas a executar em simultâneo, como mostrado na Figura 6

Figura 6

Operações Dependências

, Como mostrado na Figura 7 nós de novo criou uma série de fila pela adição de dependências entre duas tarefas. Criamos duas operações de bloqueio e nós estamos dizendo que não iniciar a tarefa 1 até que a tarefa 2 é terminar chamando blockOperations1.addDependency(blockOperations2)

Figura 7

Despacho Grupo de Implementação Usando a Fila de Operações

Na parte 2 usamos GCD de despacho recurso de grupo para bloquear a thread até que uma ou mais tarefas de terminar a execução. Conforme mostrado na Figura 8, implementamos o mesmo comportamento usando filas de operação usando dependências. Isso é muito útil se você não puder progredir até que todas as tarefas especificadas sejam concluídas.

, Como mostrado na Figura 8 temos três tarefas e queríamos ser executados simultaneamente e, quando todas as tarefas terminado precisamos chamar algum método para indicar que todas as tarefas terminou e o que nós fizemos

  1. Criada uma fila de operações
  2. Criado três bloco de operações que irá executar as tarefas
  3. Criada uma conclusão bloco de operação (blockOperations4) o que será desencadeada quando todas as três tarefas vai terminar
  4. Feito blockOperations4 dependente blockOperations1, blockOperations2 e blockOperations3 o que significa blockOperations4 será executado quando todas as três tarefas vai terminar
  5. waitUntilFinished → Blocos de execução da thread atual até que a operação objeto de terminar sua tarefa, pois não queremos bloquear a thread atual, que é o principal, nós atribuí-la com false
  6. Executar esse código e “Toda a Operação é Concluída” será impresso quando task1 e task2 task3 vai terminar

Figura 8

Como mostrado na Figura 9 temos apenas bloquear o thread principal, pela definição de waitUntilFinished = true. Então, a pergunta é quando ele é útil e você terá a resposta, na próxima seção

Figura 9

conforme mostrado na Figura 10, implementamos um comportamento de grupo de despacho usando a fila de operação sem usar Nenhuma dependência. Se você estiver no thread de fundo, poderá bloquear esse thread para alcançar esse comportamento. Eu, intencionalmente, alternado para o segmento de plano de fundo usando DispatchQueue.global().async método ver parte 1 compreender esse código

dissemos operação fila de executar a tarefa 1, task 2 e task 3 na fila de operações e bloquear a thread atual até que estas tarefas simultâneas vai terminar sua execução

Figura 10

Benefícios da Operação de Filas de Mais de GCD

  1. A Operação de API fornece suporte para dependências. Você pode criar dependências complexas entre tarefas com muita facilidade, embora no GCD você possa alcançá-lo, mas precisa fazer muito trabalho.
  2. as classes NSOperation e NSOperationQueue têm uma série de propriedades que podem ser observadas, usando KVO (Key Value Observing). Este é outro benefício importante se você deseja monitorar o estado de uma fila de operação ou operação.
  3. as operações podem ser pausadas, retomadas e canceladas. Depois de despachar uma tarefa usando o Grand Central Dispatch, você não terá mais controle ou insights sobre a execução dessa tarefa. A API NSOperation é mais flexível a esse respeito, dando ao Desenvolvedor controle sobre o ciclo de vida da operação
  4. o NSOperationQueue também adiciona uma série de benefícios ao mix. Por exemplo, você pode especificar o número máximo de operações em fila que podem ser executadas simultaneamente. Isso facilita o controle de quantas operações são executadas ao mesmo tempo ou a criação de uma fila de operação serial.

próximo

na próxima parte, veremos o caso de uso real de criação de operação personalizada

Links úteis

· https://developer.apple.com/library/archive/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationObjects/OperationObjects.html#//apple_ref/doc/uid/TP40008091-CH101-SW1

Deixe uma resposta

O seu endereço de email não será publicado.