Este documento discute a criação e controle de threads em Java, incluindo como implementar interfaces Runnable, estender a classe Thread, iniciar novos threads, interromper threads, fazer threads dormirem e esperarem por outros threads. O documento também explica a diferença entre threads user e daemon.
1. O documento discute utilitários de concorrência em Java, incluindo variáveis atômicas, unidades de tempo e coleções concorrentes.
2. Variáveis atômicas permitem operações atômicas em tipos primitivos e referências através de métodos como getAndSet e compareAndSet.
3. Updaters permitem encapsular atributos em objetos para operações atômicas como incremento e substituição de valores.
1. O documento apresenta os fundamentos de programação concorrente em Java, incluindo threads, a interface Runnable, como iniciar novos threads, interrupção de threads, espera de threads e problemas de corrida.
2. A segunda parte aborda a API de concorrência do Java, incluindo classes e interfaces do pacote java.util.concurrent.
3. O documento fornece exemplos de código para ilustrar os principais conceitos de programação concorrente em Java.
1. O documento discute tópicos sobre concorrência e paralelismo em Java, incluindo criação e controle de threads, acesso exclusivo, ciclo de vida de aplicações, variáveis atômicas e travas.
2. É introduzido o framework Fork/Join, que permite paralelizar tarefas recursivas usando a estratégia "dividir para conquistar" em CPUs multi-core.
3. São explicados conceitos como work stealing, onde threads roubam tarefas de outras filas para executar, melhorando a performance.
1) O documento discute processos, threads e suas relações no sistema operacional. Processos podem ter vários threads executando simultaneamente compartilhando o mesmo espaço de memória.
2) É explicada a estrutura de um processo incluindo contexto de hardware, software e espaço de endereçamento. Processos podem estar em diferentes estados como executando, pronto ou espera.
3) Threads são partes de um processo que executam concorrentemente, proporcionando paralelismo dentro do mesmo processo. Isso traz vantagens de desempenho em compara
O documento discute o uso de coleções em ambientes concorrentes em Java, abordando: 1) Coleções imutáveis que podem ser usadas sem travas; 2) Coleções sincronizadas que fornecem acesso thread-safe; 3) Algoritmos concorrentes do pacote java.util.concurrent que reduzem o uso de travamento.
The document discusses multithreading in Java. It defines multithreading as executing multiple threads simultaneously, with threads being lightweight subprocesses that share a common memory area. This allows multitasking to be achieved more efficiently than with multiprocessing. The advantages of multithreading include not blocking the user, performing operations together to save time, and exceptions in one thread not affecting others. The document also covers thread states, creating and starting threads, and common thread methods.
Threads 02: Acesso exclusivo e comunicação entre threadsHelder da Rocha
O documento discute comunicação entre threads em Java. Ele explica que condições de corrida podem ocorrer quando dados compartilhados são alterados por múltiplos threads de forma imprevisível. Bloco sincronizados e métodos sincronizados garantem acesso exclusivo a um objeto para um thread de cada vez, prevenindo condições de corrida. Variáveis declaradas como "volatile" garantem que threads vejam valores atualizados na memória compartilhada. Os métodos wait(), notify() e notifyAll() permitem que threads esperem por condições e se
O documento discute programação orientada a objetos, com foco nos pilares da encapsulamento, herança e polimorfismo. Apresenta exemplo de como encapsular atributos e métodos de uma classe ControleRemoto que implementa a interface Controlador.
1. O documento discute utilitários de concorrência em Java, incluindo variáveis atômicas, unidades de tempo e coleções concorrentes.
2. Variáveis atômicas permitem operações atômicas em tipos primitivos e referências através de métodos como getAndSet e compareAndSet.
3. Updaters permitem encapsular atributos em objetos para operações atômicas como incremento e substituição de valores.
1. O documento apresenta os fundamentos de programação concorrente em Java, incluindo threads, a interface Runnable, como iniciar novos threads, interrupção de threads, espera de threads e problemas de corrida.
2. A segunda parte aborda a API de concorrência do Java, incluindo classes e interfaces do pacote java.util.concurrent.
3. O documento fornece exemplos de código para ilustrar os principais conceitos de programação concorrente em Java.
1. O documento discute tópicos sobre concorrência e paralelismo em Java, incluindo criação e controle de threads, acesso exclusivo, ciclo de vida de aplicações, variáveis atômicas e travas.
2. É introduzido o framework Fork/Join, que permite paralelizar tarefas recursivas usando a estratégia "dividir para conquistar" em CPUs multi-core.
3. São explicados conceitos como work stealing, onde threads roubam tarefas de outras filas para executar, melhorando a performance.
1) O documento discute processos, threads e suas relações no sistema operacional. Processos podem ter vários threads executando simultaneamente compartilhando o mesmo espaço de memória.
2) É explicada a estrutura de um processo incluindo contexto de hardware, software e espaço de endereçamento. Processos podem estar em diferentes estados como executando, pronto ou espera.
3) Threads são partes de um processo que executam concorrentemente, proporcionando paralelismo dentro do mesmo processo. Isso traz vantagens de desempenho em compara
O documento discute o uso de coleções em ambientes concorrentes em Java, abordando: 1) Coleções imutáveis que podem ser usadas sem travas; 2) Coleções sincronizadas que fornecem acesso thread-safe; 3) Algoritmos concorrentes do pacote java.util.concurrent que reduzem o uso de travamento.
The document discusses multithreading in Java. It defines multithreading as executing multiple threads simultaneously, with threads being lightweight subprocesses that share a common memory area. This allows multitasking to be achieved more efficiently than with multiprocessing. The advantages of multithreading include not blocking the user, performing operations together to save time, and exceptions in one thread not affecting others. The document also covers thread states, creating and starting threads, and common thread methods.
Threads 02: Acesso exclusivo e comunicação entre threadsHelder da Rocha
O documento discute comunicação entre threads em Java. Ele explica que condições de corrida podem ocorrer quando dados compartilhados são alterados por múltiplos threads de forma imprevisível. Bloco sincronizados e métodos sincronizados garantem acesso exclusivo a um objeto para um thread de cada vez, prevenindo condições de corrida. Variáveis declaradas como "volatile" garantem que threads vejam valores atualizados na memória compartilhada. Os métodos wait(), notify() e notifyAll() permitem que threads esperem por condições e se
O documento discute programação orientada a objetos, com foco nos pilares da encapsulamento, herança e polimorfismo. Apresenta exemplo de como encapsular atributos e métodos de uma classe ControleRemoto que implementa a interface Controlador.
Introduzir a noção de thread, uma unidade fundamental de utilização de CPU e que representa a base da maioria dos sistemas computacionais modernos
Questões relacionadas a criação de threads
The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
O documento discute conceitos de concorrência em sistemas operacionais, incluindo: (1) a diferença entre sistemas monoprogramáveis e multiprogramáveis e as vantagens da multiprogramação; (2) o mecanismo de troca de contexto entre processos; e (3) o mecanismo de interrupções e exceções para lidar com eventos assíncronos no sistema.
[Curso Java Basico] Aula 15: Controle de Decisao Switch-CaseLoiane Groner
O documento discute o comando switch-case em Java, explicando como ele funciona como múltiplos if-else e permite escolher uma opção de acordo com o valor de uma variável. É mostrado um exemplo de como usar switch-case para imprimir o nome do dia da semana de acordo com o número correspondente.
Este documento fornece uma introdução aos conceitos básicos de orientação a objetos em Java, incluindo objetos, classes, atributos, métodos, encapsulamento, herança e polimorfismo. Ele explica que objetos podem representar entidades do mundo real e ter características e comportamentos, e que classes agrupam objetos com atributos e métodos comuns. O documento também discute como classes, métodos, construtores e variáveis de instância funcionam em Java.
O documento discute o tratamento de exceções no Java usando os blocos try/catch. Aprendemos que try monitora blocos de código para erros enquanto catch trata erros capturados. Um exemplo mostra como catch pode lidar com uma exceção ArrayIndexOutOfBounds para permitir a continuação do programa.
Python não força o programador a pensar em objetos, mas eles fazem parte da linguagem desde o início, incluindo conceitos avançados como sobrecarga de operadores, herança múltipla e introspecção. Com sua sintaxe simples, é muito natural aprender orientação a objetos em Python
The document discusses multithreading concepts like concurrency and threading, how to create and control threads including setting priorities and states, and how to safely share resources between threads using synchronization, locks, and wait/notify methods to avoid issues like deadlocks. It also covers deprecated thread methods and increased threading support in JDK 1.5.
O documento discute funções e procedimentos em C. Explica que funções retornam valores ao contrário de procedimentos e que ambos podem receber parâmetros. Também aborda passagem de parâmetros por valor e por referência e o comportamento de vetores como parâmetros.
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
O documento discute pilhas e filas, que são listas lineares especiais com disciplina restrita de organização e acesso aos seus nós. Apresenta as operações básicas de pilhas (LIFO) e filas (FIFO) e duas formas de implementação: por contiguidade física usando arranjos e por encadeamento usando ponteiros.
O documento discute frameworks e implementações para execução concorrente de tarefas em Java, incluindo Executors, ExecutorService, ThreadPoolExecutor, CompletionService e CompletableFuture. Ele explica como submeter tarefas para execução, obter resultados e controlar a finalização de threads.
Java Multi Threading Concept
By N.V.Raja Sekhar Reddy
www.technolamp.co.in
Want more...
Like us @ https://www.facebook.com/Technolamp.co.in
subscribe videos @ http://www.youtube.com/user/nvrajasekhar
A pilha é uma estrutura de dados simples onde os elementos são inseridos e removidos sempre do topo. O documento descreve as operações básicas de empilhar (push) e desempilhar (pop) e apresenta implementações de pilhas usando vetores e listas encadeadas.
Java concurrency allows applications to make use of multiple processors and handle asynchronous operations through the use of threads. While concurrency provides benefits like improved performance, it also introduces risks like race conditions and deadlocks if threads access shared resources unsafely. The Java threading APIs provide tools for safely managing concurrent operations through mechanisms like synchronization, locks, and concurrent collections.
Exercicios Vetores (Arrays) - Estruturas de dados e algoritmos com JavaLoiane Groner
O documento descreve uma série de exercícios para melhorar uma classe Lista implementando métodos semelhantes à classe ArrayList do Java, como contém, ultimoIndice, remove, obtem e limpar. Também inclui exercícios para utilizar a classe Lista e ArrayList com uma classe Contato, inserindo e acessando elementos.
Chapitre 2 de la formation "Java avancé", qui est composée de :
1 - introspection et annotations
2 - programmation concurrente
3 - communications distantes
4 - administration et supervision avec JMX
5 - utilisation du code natif avec JNI
O documento discute conceitos importantes de sincronização e comunicação entre processos, incluindo semáforos, monitores, troca de mensagens e deadlock. Semáforos são usados para exclusão mútua e sincronização condicional através de operações wait e signal. Monitores fornecem exclusão mútua automática e sincronização condicional com variáveis de condição e procedimentos. A troca de mensagens permite a comunicação direta e indireta entre processos. Deadlock ocorre quando um processo aguarda um recurso que nunca
CompletableFuture é uma API de Java para programação assíncrona e paralela baseada em fluxos de dados. Ela consiste da interface CompletionStage e sua implementação CompletableFuture, que permite concatenar operações assíncronas usando métodos como thenApply, thenAccept e runAfterBoth. CompletableFuture facilita a composição de tarefas paralelas e o tratamento de exceções em programas concorrentes.
O documento discute a implementação de threads em Java para melhorar o desempenho de aplicações. Threads permitem a execução paralela de tarefas dentro de um mesmo processo, oferecendo maior eficiência do que processos separados. O texto explica como criar, gerenciar e sincronizar threads, apresentando métodos como start(), sleep(), yield() e synchronized.
Introduzir a noção de thread, uma unidade fundamental de utilização de CPU e que representa a base da maioria dos sistemas computacionais modernos
Questões relacionadas a criação de threads
The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
O documento discute conceitos de concorrência em sistemas operacionais, incluindo: (1) a diferença entre sistemas monoprogramáveis e multiprogramáveis e as vantagens da multiprogramação; (2) o mecanismo de troca de contexto entre processos; e (3) o mecanismo de interrupções e exceções para lidar com eventos assíncronos no sistema.
[Curso Java Basico] Aula 15: Controle de Decisao Switch-CaseLoiane Groner
O documento discute o comando switch-case em Java, explicando como ele funciona como múltiplos if-else e permite escolher uma opção de acordo com o valor de uma variável. É mostrado um exemplo de como usar switch-case para imprimir o nome do dia da semana de acordo com o número correspondente.
Este documento fornece uma introdução aos conceitos básicos de orientação a objetos em Java, incluindo objetos, classes, atributos, métodos, encapsulamento, herança e polimorfismo. Ele explica que objetos podem representar entidades do mundo real e ter características e comportamentos, e que classes agrupam objetos com atributos e métodos comuns. O documento também discute como classes, métodos, construtores e variáveis de instância funcionam em Java.
O documento discute o tratamento de exceções no Java usando os blocos try/catch. Aprendemos que try monitora blocos de código para erros enquanto catch trata erros capturados. Um exemplo mostra como catch pode lidar com uma exceção ArrayIndexOutOfBounds para permitir a continuação do programa.
Python não força o programador a pensar em objetos, mas eles fazem parte da linguagem desde o início, incluindo conceitos avançados como sobrecarga de operadores, herança múltipla e introspecção. Com sua sintaxe simples, é muito natural aprender orientação a objetos em Python
The document discusses multithreading concepts like concurrency and threading, how to create and control threads including setting priorities and states, and how to safely share resources between threads using synchronization, locks, and wait/notify methods to avoid issues like deadlocks. It also covers deprecated thread methods and increased threading support in JDK 1.5.
O documento discute funções e procedimentos em C. Explica que funções retornam valores ao contrário de procedimentos e que ambos podem receber parâmetros. Também aborda passagem de parâmetros por valor e por referência e o comportamento de vetores como parâmetros.
Cette présentation concerne le développement piloté par les tests (TDD, Test-Driven Development). Cette méthodologie se base sur des tests unitaires qui testent de manière indépendante des unités de code (module, procédure/fonction, classe...). En particulier, cette présentation utilise la librairie CUnit utilisée pour le langage C.
O documento discute pilhas e filas, que são listas lineares especiais com disciplina restrita de organização e acesso aos seus nós. Apresenta as operações básicas de pilhas (LIFO) e filas (FIFO) e duas formas de implementação: por contiguidade física usando arranjos e por encadeamento usando ponteiros.
O documento discute frameworks e implementações para execução concorrente de tarefas em Java, incluindo Executors, ExecutorService, ThreadPoolExecutor, CompletionService e CompletableFuture. Ele explica como submeter tarefas para execução, obter resultados e controlar a finalização de threads.
Java Multi Threading Concept
By N.V.Raja Sekhar Reddy
www.technolamp.co.in
Want more...
Like us @ https://www.facebook.com/Technolamp.co.in
subscribe videos @ http://www.youtube.com/user/nvrajasekhar
A pilha é uma estrutura de dados simples onde os elementos são inseridos e removidos sempre do topo. O documento descreve as operações básicas de empilhar (push) e desempilhar (pop) e apresenta implementações de pilhas usando vetores e listas encadeadas.
Java concurrency allows applications to make use of multiple processors and handle asynchronous operations through the use of threads. While concurrency provides benefits like improved performance, it also introduces risks like race conditions and deadlocks if threads access shared resources unsafely. The Java threading APIs provide tools for safely managing concurrent operations through mechanisms like synchronization, locks, and concurrent collections.
Exercicios Vetores (Arrays) - Estruturas de dados e algoritmos com JavaLoiane Groner
O documento descreve uma série de exercícios para melhorar uma classe Lista implementando métodos semelhantes à classe ArrayList do Java, como contém, ultimoIndice, remove, obtem e limpar. Também inclui exercícios para utilizar a classe Lista e ArrayList com uma classe Contato, inserindo e acessando elementos.
Chapitre 2 de la formation "Java avancé", qui est composée de :
1 - introspection et annotations
2 - programmation concurrente
3 - communications distantes
4 - administration et supervision avec JMX
5 - utilisation du code natif avec JNI
O documento discute conceitos importantes de sincronização e comunicação entre processos, incluindo semáforos, monitores, troca de mensagens e deadlock. Semáforos são usados para exclusão mútua e sincronização condicional através de operações wait e signal. Monitores fornecem exclusão mútua automática e sincronização condicional com variáveis de condição e procedimentos. A troca de mensagens permite a comunicação direta e indireta entre processos. Deadlock ocorre quando um processo aguarda um recurso que nunca
CompletableFuture é uma API de Java para programação assíncrona e paralela baseada em fluxos de dados. Ela consiste da interface CompletionStage e sua implementação CompletableFuture, que permite concatenar operações assíncronas usando métodos como thenApply, thenAccept e runAfterBoth. CompletableFuture facilita a composição de tarefas paralelas e o tratamento de exceções em programas concorrentes.
O documento discute a implementação de threads em Java para melhorar o desempenho de aplicações. Threads permitem a execução paralela de tarefas dentro de um mesmo processo, oferecendo maior eficiência do que processos separados. O texto explica como criar, gerenciar e sincronizar threads, apresentando métodos como start(), sleep(), yield() e synchronized.
Programação Concorrente - Gerenciamento de Threads - Parte IFabio Moura Pereira
O documento descreve conceitos de programação concorrente em Java, incluindo:
1) Como criar e executar threads para realizar tarefas concorrentes;
2) Como recuperar informações sobre o estado e prioridade de threads;
3) Como interromper uma thread durante sua execução.
O documento discute o conceito de threads em Java. Uma thread é uma linha de execução dentro de um processo. Um processo pode ter múltiplas threads executando simultaneamente. Threads podem ser criadas extendendo a classe Thread ou implementando a interface Runnable. É necessário iniciar uma thread chamando o método start() para que ela comece a executar.
O documento discute threads em programação concorrente. Explica que threads são fluxos de execução paralelos que melhoram o desempenho de aplicativos. Detalha como criar threads usando a classe Thread ou a interface Runnable e mostra exemplos de código Java que geram números aleatórios em threads paralelas.
Sincronizadores são objetos que controlam o fluxo de threads em Java. O documento descreve implementações como Semaphore, CountDownLatch, CyclicBarrier, Exchanger e Phaser, que fornecem padrões de sincronização. A infraestrutura comum é fornecida pela classe AbstractQueuedSynchronizer.
O documento apresenta exemplos de como criar threads em Java utilizando a classe Thread diretamente e implementando a interface Runnable. Discute as vantagens de cada abordagem, sendo melhor usar Runnable quando não for necessário estender outra classe além de Thread.
O documento discute threads e sockets em Java, abordando: 1) como criar threads usando a interface Runnable ou estendendo a classe Thread; 2) um exemplo de cliente-servidor de eco usando sockets TCP para comunicação entre um servidor e vários clientes.
O documento apresenta os fundamentos da programação concorrente em Java, abordando tópicos como threads, classes Thread e Runnable, controle de threads, deadlocks e comunicação entre threads usando wait() e notify(). É apresentado um exemplo de produtor-consumidor usando uma pilha compartilhada para ilustrar o uso desses conceitos.
O documento apresenta os fundamentos da programação concorrente em Java, discutindo tópicos como threads, classes Thread e Runnable, controle de threads, deadlocks e comunicação entre threads usando wait() e notify(). É apresentado um exemplo de produtor-consumidor usando uma pilha compartilhada para ilustrar o uso desses conceitos.
O documento descreve conceitos de programação concorrente em Java, incluindo: 1) como criar e executar threads daemon; 2) como tratar exceções em threads; 3) como usar variáveis de thread locais para evitar conflitos de acesso a dados compartilhados. Exemplos de código são fornecidos para ilustrar cada tópico.
Programação Concorrente - Gerenciamento de Threads - Parte IIFabio Moura Pereira
O documento descreve conceitos de programação concorrente em Java, incluindo: 1) como criar e executar threads daemon; 2) como tratar exceções em threads; 3) como usar variáveis de thread locais para evitar conflitos de acesso a dados compartilhados. Exemplos de código são fornecidos para ilustrar cada tópico.
1) O documento discute threads e sockets em Java, apresentando exemplos de código para ilustrar o conceito de threads e sua implementação em Java. 2) É mostrado como criar threads que executam concorrentemente através da interface Runnable e da classe Thread, permitindo maior paralelismo. 3) Também são apresentados exemplos básicos de cliente e servidor TCP usando sockets para comunicação entre processos.
Paralelismo na prática: Threads de uma vez por todas e sem medo!Mario Guedes
Por vezes considerado um recurso obscuro pelos desenvolvedores Delphi, esta apresentação visa mostrar situações cotidianas que podem ser otimizadas pela aplicação de threads no Delphi, as armadilhas e erros comuns na adoção do paralelismo, e as soluções para contornar estas situações .Podemos tornar nossos aplicativos mais fluídos bem como tornar o processamento de tarefas mais rápidos. Nesta palestra veremos algumas boas práticas acerca do assunto partindo da classe TThread chegando à recente PPL (Parallel Programming Library). É um recurso importante no desenvolvimento Win32, Mobile e backend nos ajudando a tornar as aplicações assíncronas e, portanto, escaláveis.
Threads 03: Ciclo de vida, aplicações e boas práticasHelder da Rocha
Este documento discute threads concorrentes e paralelismo em Java. Ele aborda tópicos como o ciclo de vida de threads, variáveis atômicas, travas, coleções, sincronizadores, executores e futures. O documento também discute padrões e anti-padrões para aplicações concorrentes em Java.
Utilitários para Programação Concorrente em Java (2005)Helder da Rocha
O documento descreve o pacote java.util.concurrent, fornecendo ferramentas para programação concorrente em Java de forma mais simples e eficiente do que as abordagens tradicionais. Ele contém classes e interfaces para criação de threads, sincronização, coleções concorrentes e variáveis atômicas.
Em Java, usamos a classe Thread do pacote java.lang para criarmos linhas de execução paralelas. A classe Thread recebe como argumento um objeto com o código que desejamos rodar.
O documento apresenta conceitos básicos da linguagem Java, incluindo estrutura de código, classes, objetos, arrays, estruturas de controle e exercícios para praticar os tópicos abordados.
O documento discute threads em Java, explicando que threads são segmentos executados sequencialmente no processador e que Java possui primitivas de multithreading na própria linguagem. Detalha os estados de uma thread, como criar uma thread implementando a interface Runnable e iniciar sua execução, e fornece um exemplo de um sistema de chat distribuído usando threads.
Semelhante a Threads 01: Criação e controle de threads (20)
Como criar um mapa temático interativo com dados abertos e D3.jsHelder da Rocha
Apresentação realizada na trilha JavaScript The Developer's Conference (TDC) Recife 2019. Código e demonstrações disponíveis no GitHub e CodePen (veja links no final).
TDC 2019: transformando dados públicos em mapas interativosHelder da Rocha
Este documento apresenta um tutorial prático sobre como usar a biblioteca D3.js para criar mapas temáticos interativos utilizando dados abertos. O tutorial ensina como obter dados geoespaciais e temáticos de portais públicos, gerar objetos SVG com D3, aplicar projeções e recursos interativos. O código-fonte completo e demonstrações online estão disponíveis no GitHub para aprendizado e referência.
Padrões essenciais de mensageria para integração de sistemasHelder da Rocha
O documento apresenta padrões essenciais de mensageria para integração de sistemas, descrevendo: (1) 4 estratégias básicas de integração, incluindo o uso de mensageria; (2) o que é um sistema de mensageria e seus componentes; (3) 10 padrões de mensageria focados em minimizar acoplamento entre componentes.
O documento discute a visualização de dados na web, mencionando gráficos que revelam informações, interagem com dados e omitem ou enganam. Apresenta exemplos históricos de gráficos e ferramentas atuais para criação de gráficos dinâmicos e interativos. Discorre sobre como gráficos podem transmitir confiança excessiva, omitir dados e usar escalas de forma enganosa.
O documento apresenta uma introdução à visualização de dados, abordando: 1) a teoria e tipos de gráficos; 2) qualidade e aplicações de visualizações; 3) demonstrações práticas usando D3.js e Leaflet. O objetivo é comunicar e revelar informações quantitativas de forma eficiente por meio de representações visuais.
Curso de Java Persistence API (JPA) (Java EE 7)Helder da Rocha
Este documento fornece um tutorial sobre a tecnologia Java Persistence API (JPA) de acordo com a especificação Java EE 7. Resume os principais conceitos de JPA como mapeamento objeto-relacional, configuração da camada de persistência e exemplos de mapeamento de entidades usando anotações ou arquivos XML. Também fornece informações sobre exercícios práticos que serão realizados usando diferentes provedores de persistência e bancos de dados.
Este documento fornece uma introdução à Java Persistence API (JPA), abordando tópicos como: 1) relacionamentos entre objetos; 2) mapeamento objeto-relacional; 3) introdução prática com um exemplo "Hello World" utilizando JPA.
Curso de RESTful WebServices em Java com JAX-RS (Java EE 7)Helder da Rocha
Este documento fornece um tutorial sobre o desenvolvimento de serviços web RESTful usando a especificação JAX-RS no Java EE 7. Explica conceitos como recursos, métodos HTTP, templates de caminho e anotações para mapear recursos e métodos. Também fornece exemplos simples de implementação de recursos RESTful com JAX-RS.
1. O documento discute os conceitos e mecanismos de segurança padrão no Java EE, incluindo autenticação, autorização e comunicação segura.
2. São descritos os principais componentes de segurança como realms, principals, roles e as APIs de autenticação como BASIC, DIGEST e FORM.
3. São explicados os processos de autenticação na camada web e em componentes EJB, assim como o uso de SSL/TLS para comunicação segura.
Este documento fornece um resumo sobre WebServlets de acordo com a especificação Java EE 7. Ele contém informações sobre aplicações Web, WebServlets, requisições e respostas HTTP, URLs e redirecionamento, contexto da aplicação, sessão do cliente, filtros interceptadores e arquitetura MVC.
O documento discute as principais novidades do Java 8, incluindo: 1) novas expressões lambda e referências para métodos, 2) APIs de data e hora, streams e interfaces funcionais, e 3) a ferramenta Nashorn para JavaScript. Apresenta exemplos de código para ilustrar essas mudanças na sintaxe e APIs.
1. O documento discute diferentes tipos de travas (locks) em Java, incluindo ReentrantLock, ReadWriteLock, Condition e StampedLock.
2. ReentrantLock fornece funcionalidades além de synchronized como interrupção e timeouts. Condition representa condições associadas a uma trava.
3. ReadWriteLock contém travas de leitura e gravação que permitem leituras concorrentes mas bloqueiam gravações. StampedLock oferece uma alternativa mais eficiente em casos com muitas leituras.
O documento resume as principais mudanças na arquitetura modular introduzida no Java 9, incluindo:
1) A divisão do JDK e JRE em módulos menores com dependências explícitas;
2) A capacidade de criar aplicações modulares com dependências claras entre módulos;
3) As novas funcionalidades como a geração de imagens executáveis menores com jlink.
As classes de modelagem podem ser comparadas a moldes ou
formas que definem as características e os comportamentos dos
objetos criados a partir delas. Vale traçar um paralelo com o projeto de
um automóvel. Os engenheiros definem as medidas, a quantidade de
portas, a potência do motor, a localização do estepe, dentre outras
descrições necessárias para a fabricação de um veículo
A linguagem C# aproveita conceitos de muitas outras linguagens,
mas especialmente de C++ e Java. Sua sintaxe é relativamente fácil, o que
diminui o tempo de aprendizado. Todos os programas desenvolvidos devem
ser compilados, gerando um arquivo com a extensão DLL ou EXE. Isso torna a
execução dos programas mais rápida se comparados com as linguagens de
script (VBScript , JavaScript) que atualmente utilizamos na internet
1. Criação e controle
de threads
THREADSCONCORRÊNCIAE
PARALELISMOEMJAVA
Helder da Rocha (helder@summa.com.br)
1
2. 1. Criação e controle de threads
2. Acesso exclusivo e comunicação entre threads
3. Ciclo de vida, aplicações e boas práticas
4. Variáveis atômicas
5. Travas
6. Coleções
7. Sincronizadores
8. Executores e Futures
9. Paralelismo
10. CompletableFuture
THREADSCONCORRÊNCIAE
PARALELISMOEMJAVA
3. Thread
• Uma sequência contínua de instruções em execução.
• É similar a um processo (do sistema operacional) mas com escopo
limitado a uma aplicação.
• Pode executar em paralelo com outros threads
• Pode ser interrompido quantas vezes for necessário, sempre continuando
do ponto onde parou.
4. +time
Single thread Thread-1 Thread-2 Core-1 Core-2
Single core Single core Dual core
Task 1
Task 2
Task 2
Task 1
Task 1
Task 2
Threadsexecutandotarefas
5. +time
Single thread Thread-1 Thread-2 Core-1 Core-2
Single core Single core Dual core
Task 1
Task 2
Task 2
Task 1
Task 1
Task 2
Threadsexecutandotarefas
Se há um único thread para executar duas tarefas, uma
aplicação precisa executá-las em sequência.A segunda
tarefa só é iniciada quando a primeira terminar.
6. +time
Single thread Thread-1 Thread-2 Core-1 Core-2
Single core Single core Dual core
Task 1
Task 2
Task 2
Task 1
Task 1
Task 2
Threadsexecutandotarefas
Duas tarefas rodando
concorrentemente
podem demorar mais
tempo para terminar,
mas garantem maior
responsividade
O sistema operacional
é responsável pela
mudança de contexto
e decide quanto
tempo cada thread
ocupa a CPU
Duas tarefas podem
executar ao mesmo
tempo, mesmo que
haja apenas um
processador.
7. +time
Single thread Thread-1 Thread-2 Core-1 Core-2
Single core Single core Dual core
Task 1
Task 2
Task 2
Task 1
Task 1
Task 2
Threadsexecutandotarefas
Com dois processadores ou dois cores, as duas
tarefas podem executar ao mesmo tempo, sem a
necessidade de mudança de contexto.
Ainda existe um overhead que pode atrasar o início
das aplicações, mas duas tarefas longas
provavelmente terminarão mais rapidamente
quando rodam em mais de um core.
8. ThreadsemJava
• Representados pela classe java.lang.Thread.
• Qualquer programa em Java possui pelo menos um thread, que executa
as instruções do método main().
• O thread principal é chamado de “main”.
9. OobjetoThread
• Pode-se obter uma referência ao objeto Thread do main() chamando
Thread.currentThread() dentro do main() ou qualquer método
chamado diretamente por main():
Thread principal = Thread.currentThread();
• Agora é possível chamar métodos de instância da classe Thread.
System.out.println("Nome do thread: "
+ principal.getName()); // imprime main
System.out.println("Thread toString(): "
+ principal); // imprime [main, 5, main]
10. AinterfaceRunnable
• A partir do thread main, podemos criar outros threads que irão rodar em
paralelo ou disputar a CPU com o thread principal.
• Todo thread precisa de uma sequência de instruções) para executar
• O thread main executa automaticamente o conteúdo do método static
void main(String[]) disparado pela JVM
• Threads adicionais executam automaticamente o conteúdo do método
void run() de uma classe que implementa java.lang.Runnable
11. ImplementandoRunnable
• A interface java.lang.Runnable é uma interface funcional
• Uma implementação de Runnable que imprime uma linha de texto e outra com
o nome do thread que está executando as instruções.
• Threads recebem nomes e IDs automaticamente. Nomes podem ser alterados.
public interface Runnable {
void run();
}
public class RunnableHelloWorld implements Runnable {
@Override public void run() {
System.out.println("Hello world paralelo!");
System.out.println("Eu sou o thread: "
+ Thread.currentThread().getName());
}
}
12. RodandoRunnablenomesmothread
• Um objeto Runnable é um objeto Java qualquer
• O programa abaixo executa o método run() no thread principal (e
imprime também o nome deste thread):
public class ThreadExampleSync {
public static void main(String[] args) {
Runnable paralelo = new RunnableHelloWorld();
paralelo.run();
System.out.println("Thread principal: " +
Thread.currentThread().getName());
}
}
Hello world paralelo!
Eu sou o thread: main
Thread principal: main
Executando no thread main
13. ComoiniciarumnovoThread
• Para criar um novo Thread é preciso criar uma nova instância da classe
Thread, que recebe como argumento uma implementação de Runnable:
• Para iniciar (executar) o Thread e executar o conteúdo de run() através
desse novo Thread chame o método start() do Thread:
Runnable tarefa = new ImplementacaoDeRunnable();
Thread t = new Thread(tarefa);
t.start();
14. ExecutandoRunnableemnovoThread
• O programa abaixo cria um novo Thread com a tarefa Runnable e depois
o inicia com o método start():
public class ThreadExampleAsync {
public static void main(String[] args) {
Runnable paralelo = new RunnableHelloWorld();
Thread t1 = new Thread(paralelo);
t1.start();
System.out.println("Thread principal: " +
Thread.currentThread().getName());
}
} Thread principal: main
Hello world paralelo!
Eu sou o thread: Thread-0Executando no thread Thread-0
15. main() {
Runnable task = new RunnableHelloWorld();
Thread t1 = new Thread(task);
t1.start();
System.out.print("Fim");
}
run() {
for(int i = 0; i < 10000; i++)
System.out.println(i);
}
Thread: main
Thread: Thread-0
main is done
Thread-0 is done
JVM is done
JVM
ExecutandoRunnableemnovoThread
16. Outrasformasdecriarthreads
• Estendendo a classe Thread
• Usando classes internas ou anônimas para implementar tarefas
• Usando expressões lambda para implementar tarefas
17. EstendendoaclasseThread
public class ThreadExampleAsync5 {
static class HelloThread extends Thread {
@Override public void run() {
System.out.println("Hello world from thread "
+ this.getName());
}
}
public static void main(String[] args) {
new HelloThread().start();
System.out.println("Thread principal: "
+ Thread.currentThread().getName());
}
}
18. Tarefacomoclasseinterna
public class ThreadExampleAsync2 {
public static void main(String[] args) {
class HelloParalelo implements Runnable {
@Override public void run() {
System.out.println("Hello world paralelo!");
}
}
Thread t1 = new Thread(new HelloParalelo());
t1.start();
System.out.println("Thread principal: "
+ Thread.currentThread().getName());
}
}
19. Tarefacomoclasseanônima
public class ThreadExampleAsync3 {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override public void run() {
System.out.println("Hello world paralelo!");
}
});
t1.start();
System.out.println("Thread principal: "
+ Thread.currentThread().getName());
}
}
20. Tarefacomoexpressãolambda
public class ThreadExampleAsync4 {
public static void main(String[] args) {
Thread t1 = new Thread(
() -> System.out.println("Hello world paralelo!") );
t1.start();
System.out.println("Thread principal: "
+ Thread.currentThread().getName());
}
}
21. Interrupçãodethreads
• Um thread só termina (normalmente) quando run() terminar.
• Métodos de interrupção não interrompem o thread. Ligam flag (INTERRUPT)
que deve ser usado para finalizá-lo (fazer run() terminar normalmente).
• Métodos de instância:
• void interrupt() – liga o flag INTERRUPT.
• boolean isInterrupted() – retorna true se INTERRUPT é true.
• Método estático (atua sobre Thread.currentThread()):
• static boolean interrupted() – retorna true se INTERRUPT for
true e em seguida muda INTERRUPT para false.
22. Threadqueterminacominterrupt()
public class InterruptRunnable implements Runnable {
@Override public void run() {
boolean interrupt = false;
while(!interrupt) {
interrupt = Thread.interrupted();
System.out.println(">INTERRUPT flag: " + interrupt);
}
System.out.println("INTERRUPTED flag: " + interrupt);
System.out.println("Thread "
+ Thread.currentThread().getName() + " is DONE!");
}
}
Repete enquanto
interrupt for false
23. maininterrompendoThread-0
public class InterruptFlagExample {
public static void main(String[] args) {
Runnable runnable = new InterruptRunnable();
Thread t1 = new Thread(runnable);
t1.start();
// outras tarefas executadas pelo thread principal
t1.interrupt(); // liga o flag de interrupção em t1
System.out.println("Thread "
+ Thread.currentThread().getName() + " is DONE!");
}
}
24. Pondothreadsparadormir
• O thread que está executando pode suspender sua execução por um
determinado tempo chamando Thread.sleep(milissegundos)
• Para dormir 1 segundo (1000 milissegundos):
• Thread.sleep(1000);
• Nesse intervalo, outros threads que estejam esperando acesso à CPU terão
oportunidade de executar, independente de sua prioridade.
• O método sleep() precisa lidar com InterruptedException
25. InterruptedException
• Será lançada se a flag INTERRUPT estiver ativada em um thread durante a
execução de sleep()
• Checked exception: precisa ser capturada ou declarada
• Isto pode ser usado para finalizar um thread, sem a necessidade de testar o
flag INTERRUPT
• Bloco try-catch pode capturar a exceção e finalizar o thread normalmente
• Bloco try-catch pode ignorar a exceção e a interrupção (a exceção
automaticamente muda o estado do INTERRUPT para false)
26. Finalizaçãocom
InterruptedException
public class RandomLetters implements Runnable {
@Override public void run() {
try {
while(true) {
System.out.print(" " + (char)('A' + new Random().nextInt(26)));
Thread.sleep(200);
}
} catch (InterruptedException e) {
System.out.println("n" + Thread.currentThread().getName() + " interrupted.");
System.out.println("INTERRUPTED flag: " + Thread.currentThread().isInterrupted());
}
System.out.println("Thread " + Thread.currentThread().getName() + " is DONE!");
}
}
public class InterruptSleepExample {
public static void main(String[] args) {
Thread t1 = new Thread(new RandomLetters());
t1.start();
// main thread executa suas tarefas
t1.interrupt(); // sets interrupt flag in t1
System.out.println("nThread " +
Thread.currentThread().getName() + " is DONE!");
}
}
27. Religandooflagdeinterrupção
• Se o código decidir não interromper o thread, outra parte do programa
poderá assumir essa responsabilidade (é preciso religar o flag)
public void run() {
while(true) { // este loop continua mesmo com interrupção
try {
// chamadas externas que poderão lidar com o INTERRUPT
Thread.sleep(100);
} catch(InterruptedException e) {
System.out.println("Thread interrompido que não será finalizado."));
Thread.currentThread().interrupt(); // IMPORTANTE!
}
}
System.out.println("Thread finalizado."));
}
InterruptedException
desliga flag de interrupção
Liga novamente o flag
de interrupção
28. Esperandothreadsterminarem
• O método join() faz um thread esperar que o outro termine
• Se um thread t1 chama t2.join(), t1 é suspenso até que t2 termine
• Como todos os métodos que suspendem threads, join() lança
InterruptedException, que precisa ser capturada ou declarada.
Thread t1 = new Thread(() -> {
for(int i = 0; i < 10000; i++) System.out.println(i);
});
t1.start();
System.out.println("Waiting for " + t1.getName());
t1.join();
System.out.println("Thread main is DONE!");
29. main() {
Runnable task = new RunnableLoop();
Thread t1 = new Thread(task);
t1.start();
t1.join();
}
run() {
for(int i = 0; i < 10000; i++)
System.out.println(i);
}
Thread: main
Thread: Thread-1
main is done
Thread-1 is done
JVM is done
JVM
WAITING
for
Thread-1
Esperandothreadsterminarem
30. Daemonthreads
• Dois tipos de threads: user threads e daemon threads.
• Daemon threads existem apenas para servir aos user threads e são
destruídos quando não houver user threads executando
• User threads: o thread main e todos os threads criados até agora neste curso
• Daemon threads: garbage collector, ForkJoinPool
• Todo thread nasce user thread, exceto se for criado por um daemon thread,
ou se o método setDaemon(true) for chamado antes de começar a executar.
31. Daemonthreads
main() {
Runnable task = new RunnableHelloWorld();
Thread t1 = new Thread(task);
t1.setDaemon(true);
t1.start();
}
run() {
for(int i = 0; i < 10000; i++)
System.out.println(i);
}
Thread: main
Thread: Thread-1
main is doneJVM is done
JVM
Thread-1 interrupted