Merge pull request #45 from duke-certification/develop

Primeira versão estável do livro

Author: rcmoutinho

.idea/compiler.xml

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Rinaldo Pitzer e Rodrigo Moutinho
+Copyright (c) 2019 Rinaldo Pitzer Jr. e Rodrigo Moutinho
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE.asc

@@ -1,10 +1,10 @@
-= Guia Open Source para Certificação: Atualize sua certificação Java 6 para Java 8
+= Guia Prático para Certificação: Atualize sua certificação Java 6 para Java 8
 
-image:https://img.shields.io/travis/com/duke-certification/java6-to-java8.svg[Travis (.com)] image:https://img.shields.io/github/release/duke-certification/java6-to-java8.svg[GitHub release] image:https://img.shields.io/github/release-date/duke-certification/java6-to-java8.svg[GitHub Release Date] image:https://img.shields.io/github/downloads/duke-certification/java6-to-java8/total.svg[GitHub All Releases] image:https://img.shields.io/github/issues/duke-certification/java6-to-java8.svg[GitHub issues] image:https://img.shields.io/github/license/duke-certification/java6-to-java8.svg[GitHub License]
+image:https://img.shields.io/travis/com/duke-certification/java6-to-java8.svg[Travis (.com), link=https://travis-ci.com/duke-certification/java6-to-java8] image:https://img.shields.io/github/release/duke-certification/java6-to-java8.svg[GitHub release] image:https://img.shields.io/github/release-date/duke-certification/java6-to-java8.svg[GitHub Release Date] image:https://img.shields.io/github/downloads/duke-certification/java6-to-java8/total.svg[GitHub All Releases] image:https://img.shields.io/github/issues/duke-certification/java6-to-java8.svg[GitHub issues] image:https://img.shields.io/github/license/duke-certification/java6-to-java8.svg[GitHub License]
 
 Este projeto serve como material de apoio na realização do exame *https://education.oracle.com/upgrade-to-java-se-8-ocp/pexam_1Z0-813[1Z0-813]* que atualiza qualquer profissional com certificação Java 6 ou inferior, para a versão 8. No momento desta documentação, o _voucher_ do exame custa R$ 597,00 no Brasil.
 
-image::images/ebook-1-400x400.png[Guia Open Source para Certificação,align="center"]
+image::images/ebook-400x400.png[Guia Open Source para Certificação,align="center"]
 
 Baixe a versão mais recente do ebook https://github.com/duke-certification/java6-to-java8/releases[no link de releases].
 
@@ -31,7 +31,7 @@ docker run --rm -v <caminho>:/documents/ asciidoctor/docker-asciidoctor scripts/
 
 == Referências
 
-Em todas sessões do livro são feitas referências diretas as fontes de inspiração ou argumentação base para a criação deste conteúdo. A seguir o resumo dessas e de outras referências que também fizeram parte dessa jornada de aprendizado.
+Em todas sessões do livro são feitas referências diretas as fontes de inspiração ou argumentação base para a criação deste conteúdo. A seguir o resumo das principais e de outras referências que também fizeram parte dessa jornada de aprendizado.
 
 Para criação da estrutura do projeto deste livro foi utilizado como base o projeto https://github.com/rcmoutinho/ebook-with-asciidoctor[ebook-with-asciidoctor].
 
@@ -43,7 +43,7 @@ Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8
 +
 https://www.amazon.com.br/dp/B0191U2H8C[Link na loja Amazon Brasil].
 
-* *(en-US)* Blog do Eugen (Baeldung) com dezenas de artigos focados em Java e também outros assuntos.
+* *(en-US)* Blog do Eugen (Baeldung) com dezenas de artigos focados em Java, entre outros assuntos.
 +
 https://www.baeldung.com/category/java/
 
@@ -63,6 +63,6 @@ https://www.alura.com.br/formacao-certificacao-java
 
 * *(pt-BR)* Canal do YouTube https://www.youtube.com/channel/UCyRDiqqSkqGvTE_wIB1nN1w[RinaldoDev] com vídeos explicativos de diversos conceitos da linguagem Java.
 
-* *(en-US)* https://www.youtube.com/playlist?list=PL3py5YSIGvPMgKXOVqnYn9nBoT_zvsvsi[_Java Challenges Explanations_], uma playlist no Youtube do canal do https://twitter.com/RafaDelNero[Rafael Del Nero] que explica desafios de Java para ensinar conceitos importantes da linguagem.
+* *(en-US)* https://www.youtube.com/playlist?list=PL3py5YSIGvPMgKXOVqnYn9nBoT_zvsvsi[_Java Challengers_], uma playlist no Youtube do canal do https://twitter.com/RafaDelNero[Rafael Del Nero] que explica desafios de Java para ensinar conceitos importantes da linguagem.
 
 * *(en-US)* https://devgym.oracle.com/pls/apex/dg/competition/java[Oracle Dev Gym], desafios online e gratuitos para testar suas habilidades de Java.

README.asc

@@ -1,3 +1,5 @@
 === Objetivos
 
-Em breve...
+Como guia para criação deste livro foi utilizado todos os objetivos citados na seção _"Review Exam Topics"_, de acordo com o https://education.oracle.com/upgrade-to-java-se-8-ocp/pexam_1Z0-813[site da certificação].
+
+A missão deste livro é criar o maior número de exemplos práticos possíveis para ajudar você a colocar a mão na massa. Quanto maior for seu contato com os códigos da versão 8 do Java, mais confiante estará na hora do exame, e também para lidar com projetos em Java 8 no mercado de trabalho.

book/01-getting-started/sections/02-objectives.asc

@@ -114,7 +114,7 @@ B
 +
 Perceba que a ordem foi respeitada na última operação do _Stream_, o `forEachOrdered`, mas não foi respeitada na execução da operação intermediária `map`. Isso ocorre porque essa operação intermediária não precisa seguir a ordem dos itens do stream.
 
-. A operação `findAny` pode trazer qualquer resultado em uma operação paralela.
+. Diferente da execução em um _Stream_ sequencial, a operação `findAny` traz resultados realmente aleatórios ao ser executada em um _Stream_ paralelo.
 +
 [source,java,indent=0]
 .{java-package}/parallelstreams/Streams_ParallelFindAny.java

book/05-java-streams/sections/02-parallel-streams.asc

@@ -0,0 +1,137 @@
+:java-package: src/org/j6toj8/concurrency
+:section-java-package: ../../../{java-package}
+
+=== Pacote `Concurrent`
+
+.Objetivo
+--------------------------------------------------
+Use classes from the java.util.concurrent package including CyclicBarrier and CopyOnWriteArrayList with a focus on the advantages over and differences from the traditional java.util collections
+-
+Usar classes do pacote java.util.concurrent, incluindo CyclicBarrier e CopyOnWriteArrayList, com foco nas vantagens e diferenças das Coleções tradicionais do pacote java.util
+--------------------------------------------------
+
+O pacote `java.util.concurrent` inclui inúmeras classes para serem utilizadas em aplicações multi-thread. Nesta seção serão apresentadas algumas dessas classes.
+
+Muitas das classes do pacote concurrent são apenas versões das coleções comuns, porém com blocos __syncronized__, garantindo que múltiplas _threads_ poderão acessá-las ao mesmo tempo mantendo sua integridade. As classes __ConcurrentHashMap__, _ConcurrentLinkedQueue_ e _ConcurrentLinkedDeque_ são exemplos disso. Por isso é importante conhecer e lembrar das coleções comuns do Java 6.
+
+Todas as seções deste capítulo podem conter exemplos maiores do que os que foram apresentados até agora, principalmente quando for necessário a criação de mútiplas __Threads__. É importante dedicar um tempo maior para entender cada um desses exemplos.
+
+. É possível criar uma *Fila* que lança uma exceção após um tempo predefinido utilizando a classe ``LinkedBlockingQueue``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_LinkedBlockingQueue.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_LinkedBlockingQueue.java[tag=code]
+----
+
+. É possível criar uma *Fila Duplamente Ligada (Deque)* que lança uma exceção após um tempo predefinido utilizando a classe ``LinkedBlockingDeque``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_LinkedBlockingDeque.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_LinkedBlockingDeque.java[tag=code]
+----
+
+. É possível criar uma lista que aloca todo o seu conteúdo em um novo _array_ sempre que é modificada utilizando a classe ``CopyOnWriteArrayList``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_CopyOnWriteArrayList.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_CopyOnWriteArrayList.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+A
+B
+C
+Lista final: [A, B, C, D]
+----
++
+Perceba que foi possível acrescentar um valor na lista durante a execução do _forEach_. Em uma lista tradicional haveria ocorrido uma ``ConcurrentModificationException``.
++
+Perceba também que, mesmo alterando a lista dentro do __forEach__, a letra "D" não aparece no console. Isso ocorre pois, quando a letra "D" foi inserida na lista, um novo _array_ foi alocado internamente contendo todos os novos elementos, e a iteração continuou ocorrendo no _array_ antigo.
+
+. É possível criar versões _syncronized_ de coleções utilizando métodos utilitários da classe ``Collections``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_CollectionsSyncronized.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_CollectionsSyncronized.java[tag=code]
+----
+
+. *Não* é possível adicionar ou remover elementos durante o _forEach_ de uma coleção sincronizada que foi criada utilizando o método da classe ``Collections``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_CollectionsSyncronizedForEach.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_CollectionsSyncronizedForEach.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Exception in thread "main" java.util.ConcurrentModificationException
+	at java.util.HashMap$HashIterator.nextNode(HashMap.java:1445)
+	at java.util.HashMap$EntryIterator.next(HashMap.java:1479)
+	at java.util.HashMap$EntryIterator.next(HashMap.java:1477)
+	at org.j6toj8.concurrency.concurrentpackage.Concurrency_CollectionsSyncronizedForEach.main(Concurrency_CollectionsSyncronizedForEach.java:18)
+----
++
+Perceba que, apesar do `Map` ter sido transformado em __syncronized__, não é possível alterá-lo durante uma iteração com __forEach__. Isso é possível apenas nas versões _Concurrent_ das coleções.
+
+. É possível sincronizar a execução de várias _threads_ utilizando a classe ``CyclicBarrier``.
++
+[source,java,indent=0]
+.{java-package}/concurrentpackage/Concurrency_CyclicBarrier.java
+----
+include::{section-java-package}/concurrentpackage/Concurrency_CyclicBarrier.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Thread-2: Primeira Parte
+Thread-1: Primeira Parte
+Thread-0: Primeira Parte
+Thread-1: Segunda Parte
+Thread-2: Segunda Parte
+Thread-0: Segunda Parte
+Thread-0: Terceira Parte
+Thread-1: Terceira Parte
+Thread-2: Terceira Parte
+----
++
+Neste exemplo estão sendo criadas 3 __threads__. Todas executam instâncias da classe `Acao` que recebem a mesma instância da classe ``CyclicBarrier``. Toda vez que uma _thread_ faz uma chamada ao método `await` da instância de ``cyclicBarrier``, ela fica suspensa até que todas as outras _threads_ cheguem até aquele mesmo ponto. Por isso todas as _threads_ imprimem no console de forma sincronizada. Se não houvesse sincronização, a saída no console seria completamente imprevisível. Abaixo é o exemplo de uma execução sem a chamada ao método `await`:
++
+.Saída no console caso não houvesse CyclicBarrier
+[source,console]
+----
+Thread-0: Primeira Parte
+Thread-1: Primeira Parte
+Thread-1: Segunda Parte
+Thread-1: Terceira Parte
+Thread-2: Primeira Parte
+Thread-0: Segunda Parte
+Thread-2: Segunda Parte
+Thread-0: Terceira Parte
+Thread-2: Terceira Parte
+
+----
+
+****
+
+* Using Concurrent Collections
++
+Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 358). Wiley. Edição do Kindle. 
+
+* https://www.baeldung.com/java-util-concurrent[Overview of the java.util.concurrent.]
+
+* https://www.baeldung.com/java-cyclic-barrier[CyclicBarrier in Java.]
+
+* https://docs.oracle.com/javase/tutorial/essential/concurrency/collections.html[Concurrent Collections.] The Java™ Tutorials.
+
+* https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html[Package java.util.concurrent.] Java Plataform SE 8.
+
+****

book/06-concurrency/sections/01-concurrent-package.asc

@@ -0,0 +1,173 @@
+:java-package: src/org/j6toj8/concurrency
+:section-java-package: ../../../{java-package}
+
+=== Locks
+
+.Objetivo
+--------------------------------------------------
+Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util.concurrent.locks and java.util.concurrent.atomic packages to support lock-free thread-safe programming on single variables
+-
+Usar classes dos tipos Lock, ReadWriteLock, e ReentrantLock dos pacotes java.util.concurrent.locks e java.util.concurrent.atomic para suportar programação sem bloqueio e multi-thread em variáveis únicas
+--------------------------------------------------
+
+As classes e interfaces `Lock`, `ReadWriteLock` e `ReentrantLock` permitem obter diferentes tipos de _Locks_ (em tradução livre: bloqueios ou travas). Esses _Locks_ são utilizados para que um número limitado de _threads_ tenham acesso a mesma variável em um determinado momento, ou para que apenas uma delas possa alterar seu valor.
+
+Nesta seção serão apresentados exemplos utilizando essas classes e interfaces. Assim como em outras seções deste capítulo, os exemplos podem ser grandes quando for necessário a criação de __threads__. Dedique um tempo maior para entendê-los completamente.
+
+==== Reentrant Lock
+
+. É possível adquirir um _Lock_ utilizando a classe ``ReentrantLock``.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_ReentrantLock.java
+----
+include::{section-java-package}/locks/Locks_ReentrantLock.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+ABC
+----
++
+Perceba que o _lock_ é removido dentro de um bloco ``finally``. Isso garante que uma _thread_ não irá ficar com um _lock_ indeterminadamente.
+
+. Chamar o método unlock sem ter obtido um lock anteriormente irá lançar uma exceção.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_UnlockWithoutLock.java
+----
+include::{section-java-package}/locks/Locks_UnlockWithoutLock.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+ABC
+Exception in thread "main" java.lang.IllegalMonitorStateException
+	at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
+	at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
+	at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
+	at org.j6toj8.concurrency.locks.Locks_UnlockWithoutLock.main(Locks_UnlockWithoutLock.java:14)
+----
+
+. É possível tentar obter um _lock_ imediatamente utilizando o método ``tryLock``.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_TryLock.java
+----
+include::{section-java-package}/locks/Locks_TryLock.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+ABC
+----
+
+. Também é possível tentar obter um _lock_ definindo um tempo de espera máximo.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_TryLockTimeout.java
+----
+include::{section-java-package}/locks/Locks_TryLockTimeout.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+ABC
+----
+
+. Em um cenário com várias __threads__, é possível que apenas uma delas consiga obter um __lock__.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_TryLockMultithread.java
+----
+include::{section-java-package}/locks/Locks_TryLockMultithread.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Thread-0: Conseguiu o Lock
+Thread-2: Conseguiu o Lock
+----
++
+Nesta execução com 3 __threads__, apenas duas conseguiram obter o _lock_ imediatamente e imprimir no console. Porém o resultado é imprevisível. Podem existir execuções onde todas obterão o __lock__, e outras em que apenas uma thread conseguirá.
+
+. Uma _thread_ pode obter mais de um _lock_ no mesmo objeto ``Lock``, mas deve desfazer o _lock_ múltiplas vezes também.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_LockTwice.java
+----
+include::{section-java-package}/locks/Locks_LockTwice.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+ABC
+----
++
+Como a _thread_ chamou `lock` duas vezes, caso ela não houvesse chamado `unlock` duas vezes, outra _thread_ não seria capaz de obter o __lock__.
+
+. É possível garantir uma distribuição mais "justa" de _locks_ passando `true` como argumento para o ``ReentrantLock``.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_Fair.java
+----
+include::{section-java-package}/locks/Locks_Fair.java[tag=code]
+----
++
+Ao passar o argumento ``true``, quando várias _threads_ estiverem esperando pelo mesmo __lock__, ele será dado àquela _thread_ que está aguardando a mais tempo.
+
+==== ReentrantReadWriteLock
+
+. É possível separar _locks_ de leitura e escrita utilizando a classe ``ReadWriteLock``. _Locks_ de leitura podem ser obtidos por múltiplas _threads_, porém _locks_ de escrita não.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_ReadWriteLock.java
+----
+include::{section-java-package}/locks/Locks_ReadWriteLock.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Thread-0: Conseguiu o Lock de leitura
+Thread-2: Conseguiu o Lock de leitura
+Thread-1: Conseguiu o Lock de leitura
+Thread-1: Conseguiu o Lock de escrita
+----
++
+Perceba que todas as _threads_ conseguiram obter o _lock_ de leitura, porém apenas uma conseguiu obter o _lock_ de escrita.
+
+. Se uma _thread_ já possuir o _lock_ de escrita, outras não conseguirão obter nem mesmo o _lock_ de leitura.
++
+[source,java,indent=0]
+.{java-package}/locks/Locks_ReadWriteLockInverted.java
+----
+include::{section-java-package}/locks/Locks_ReadWriteLockInverted.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Thread-0: Conseguiu o Lock de escrita
+Thread-0: Conseguiu o Lock de leitura
+----
++
+Perceba que neste exemplo o _lock_ de escrita está sendo obtido *antes* do de leitura, de tal forma que apenas a primeira _thread_ que foi executada conseguiu obter os dois __locks__.
+
+****
+
+* Applying Locks
++
+Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 607). Wiley. Edição do Kindle. 
+
+* https://www.baeldung.com/java-concurrent-locks[Guide to java.util.concurrent.Locks.]
+
+* https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/package-summary.html[Package java.util.concurrent.locks.] Java Plataform SE 8.
+
+****