SEÇÃO 1
Programação
concorrente e threads
Você já se perguntou como o computador consegue executar várias coi- sas ao mesmo tempo? Essa é uma grande vantagem que a máquina tem sobre os seres humanos.
Ouvir música e utilizar um editor de texto para escrever sobre algo que você está pesquisando na internet... Como o computador consegue fazer isso ao mesmo tempo? O computador divide essas tarefas em processos, ou seja, cada ação executada por ele é um novo processo. Por serem exe- cutados todos ao mesmo tempo, dizemos que são processos paralelos. Até aqui tudo bem, cada atividade é um processo, mas imagine que o nosso sistema esteja sendo executado, então, torna-se um processo para o sistema operacional do computador. Agora, imagine que dentro do nosso sistema precisamos fazer mais de uma atividade por vez, como fazer isso? Precisamos enviar um email, ao mesmo tempo em que um cliente realiza um cadastro de usuário ou exibir a interface gráfica para que o usuário possa visualizar o sistema.
Tudo isso está sendo feito em paralelo, então, como controlar isso tudo? Criar mais processos? Nesse caso não, existe outro conceito que são as
threads. Se dentro de um processo, temos várias atividades, que devem
ser executas em paralelo, será preciso criar threads para gerenciar tudo isso.
No Java, existe mais de uma forma de se utilizar as threads, porém, aqui você vai aprender a forma considerada mais correta, que é implemen- tando a interface Runnable. Essa interface implementa uma thread. Fa-
zendo isso no Java, teremos a seguinte classe: public class Sistema implements Runnable{
//implementação dos métodos }
A classe que chamamos de Sistema, implementa a interface Runnable, e ao implementar essa a classe precisa implementar o método run, que
é responsável por dar início à execução da thread. Veja no exemplo a seguir, uma implementação desse método.
public class Sistema implements Runnable{
private String nome;
//get e set para a variável nome public void run() {
int i = 0; while(i<10){
System.out.println(“Sistema executado por “ + nome + ”!”); i++;
} } }
No exemplo, o método run imprimirá uma frase dez vezes, informando quem executou o sistema. Para iniciar a thread, basta chamar tal método. Veja no exemplo a seguir.
public class Principal{
public static void main(String[] args) {
Sistema sis = new Sistema(); sis.setNome(“Maria”); new Thread(sis).start();
} }
Devemos criar um objeto da classe Sistema, que é a classe que imple- menta uma thread, feito isso, colocamos um valor para o atributo nome e em seguida criamos uma nova thread para receber o nosso sistema. A chamada ao método start() é que vai iniciar a execução do método run() da classe sistema. Nesse caso, a frase que será impressa é a seguinte:
Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria! Sistema executado por Maria!
Para visualizar a execução dos sistemas em paralelo, podemos iniciar várias execuções ao mesmo tempo, alterando o método main para iniciar vários sistemas. Com a alteração, fica assim:
public class Principal
{
public static void main(String[] args) {
Sistema sis = new Sistema(); sis.setNome(“Maria”); new Thread(sis).start();
Sistema sis2 = new Sistema(); sis2.setNome(“João”); new Thread(sis2).start();
Sistema sis3 = new Sistema(); sis3.setNome(“Pedro”); new Thread(sis3).start();
Sistema sis4 = new Sistema(); sis4.setNome(“Julia”); new Thread(sis4).start();
} }
Com a alteração realizada no método main, quatro pessoas estão ini- ciando seus sistemas, nesse caso, serão impressas quarenta frases, só que dessa vez, elas serão impressas intercaladas, pois a execução dos sistemas é realizada em paralelo, devido ao uso das threads. As frases ficam da seguinte forma:
Sistema executado por Maria! Sistema executado por Maria! Sistema executado por João! Sistema executado por Pedro! Sistema executado por Maria! Sistema executado por Julia! Sistema executado por Julia! Sistema executado por Pedro! Sistema executado por João! Sistema executado por Julia! Sistema executado por Pedro! Sistema executado por João! Sistema executado por Maria! Sistema executado por João! Sistema executado por Pedro! Sistema executado por Maria! Sistema executado por Maria! ...
Observando as frases, podemos perceber que os sistemas estão sendo executados em paralelo, pois se não estivessem primeiro, seriam impres- sas todas as frases com o nome de Maria, depois todas com o nome João, depois as do Pedro e por último as frases da Julia, pois essa foi a ordem que chamamos o método run() no main.
Imagine agora, que existem métodos que não podem ser executados ao mesmo tempo por threads diferentes, pois podem causar inconsistências de valores no sistema. Para que isso não ocorra, podemos controlar o acesso aos métodos, ou até mesmo a blocos de códigos dentro de mé- todos, de modo que apenas uma thread execute esse bloco e as demais ficam esperando a sua vez na fila. Para isso, utilizamos a palavra-chave synchronized.
Vamos alterar a classe Principal para chamar um método synchronized, e imprimir as nossas frases de execução do sistema. Veja como ficariam as alterações
public class Sistema implements Runnable{
private String nome;
//get e set para a variável nome
public synchronized void iniciarSistema(){
int i = 0; while(i<10){
System.out.println(“Sistema executado por “ + nome + ”!”); i++;
} }
public void run() {
iniciarSistema(); }
}
No exemplo foi criado um novo método, e colocado tudo que estava no método run dentro desse novo método, chamado de iniciarSistema. A diferença é que o método foi criado, utilizando a palavra chave synchro- nized junto ao modificador de acesso.
Com essa alteração, ao executar o programa, as frases não ficaram inter- caladas, e sim agrupadas de dez em dez, pois o método que imprime as frases só pode ser acessado por meio de uma thread por vez.
Pode-se, ainda, deixar apenas uma parte do código como synchronized,
public void iniciarSistema(){ synchronized(this){ int i = 0; while(i<10){ System.out.println(“Sistema “ + i + “ em execução!”); i++; } } //continuação do método }
Nesse caso, mais de uma thread pode chegar até o método iniciarSiste- ma, porém no trecho que está entre o bloco synchronized, apenas uma
thread poderá ser executada por vez.
Utilizando as threads, é possível realizar várias atividades ao mesmo
tempo no mesmo sistema, e ainda controlar quando uma ou mais threads
podem acessar um determinado método ou trecho de código do nosso sistema simultaneamente.
Finalizando
Parabéns, você acaba de concluir mais uma etapa do Curso Técnico em Informática. Durante o estudo você pôde entender que tudo o que está ao nosso redor pode se tornar um objeto e pode ser representado dentro de um sistema. Entendeu que o reaproveitamento de código re- duz o tempo de desenvolvimento de um sistema, auxilia no momento de manutenir o sistema e facilita o entendimento, entre outras vantagens.
A orientação a objetos é empregada em inúmeras linguagens e é utilizada por grandes em- presas. Tendo conhecimento dos conceitos fundamentais da POO, o profissional aprende outras linguagens mais facilmente, sem contar que o conhecimento das práticas da orientação a objeto é um grande diferencial no momento de buscar uma vaga no mercado de trabalho. É recomendável que, de vez em quando, você releia as unidades de estudos e aperfeiçoe seus conhecimentos buscando outras fontes de informação. Nunca pare de estudar, a infor- mática está em constante evolução, e é nosso papel acompanhá-la para sermos profissionais de sucesso.
Referências
▪ BOOCH, Grady; RUMBAUGH, James; JACOBSON, Ivar. UML – Guia do Usuário. 2.
ed. Rio de Janeiro: Campus, 2006.
▪ DEITEL, Paul J. Java: como programar. 6. ed. São Paulo: Pearson, 2005. 1152 p.
▪ SIERRA, Kathy; BATES, Bert. Use a cabeça! Java. Tradução da segunda edição. Rio de
janeiro, RJ: Editora Alta Books, 2005. 470 p.