É necessário a Leitura do Básico de uma instancia da JVM, Falaremos da estrutura de uma thread, a estrutura de um processo e Basicamente de PC Registers e STACK.
Java Virtual Machine Stacks : - Normalmente chamada somente de
Stack - , cada thread tem a sua Stack.(Ou seja um processo tem ao Menos uma STACK - Pois um processo tem ao menos uma thread-).
Oque contem dentro de uma Stack?
De um modo geral, FRAMES.
Toda vez que um método é invocado em java, cria-se um Frame ao método na STACK referente aquela thread. Toda Stack tem pelo menos um frame(ou um método) que vai no fim dela, o mais conhecido é o main().
Oque eu tenho dentro de uma Frame? - Basicamente -
-Local Variables
-Uma referência para Constante Pool da Classe
-Operand Stack
*** Cada Frame contem um LIFO, conhecido com Operand Stack (last-in-first-out)- A stack em si também é conhecida com LIFO
Ai você me pergunta e dai? - A relação de como java trabalha com os dados, é a mesma que o Frame faz – Por isso da importância de saber isso.
Perceba que em java basicamente trabalhamos com 3 tipos de dados em um contexto de um processo: Local Variables, Membros de Instancia, Membros de Classe. A relação é a seguinte:
- Local Variables = São variáveis locais ao Método(Ou seja são variaveis que residem dentro da Local variable de uma Frame).
- Membros de Instancia = Cada arquivo.class contem um Constant Pool que são Referências simbólicas a tudo em Heap. Qual a Relação Constant Pool e Runtime Constant Pool? Quando o arquivo.class é carregado existe uma mapiamento e a Constant Pool do arquivo.class vira a Runtime Constant Pool na instancia da JVM. -Isso será futuramente a Heap daquele PROCESSO -
- Membros de Classe = Normalmente trabalhando na Operand Stack Referente - Usa - se simbólicas importações em bytecode do tipo, getStatic, putStatic. etc.
Ja percebeu da onde em java, você aprende...Declarando Membros de instancia,Declarando membros da classe, Declarando Local variables...Pois bem ai está da onde vem.
Local Variables - O -Index 0 - é usado como uma Referência a Constant Pool, que vai para a Operand Stack para invocações de OPCODE do tipo - putfield #2 ; EM JAVA TEMOS A KEYWORD this, ela tem a mesma função que o -Index 0- Isso quer dizer que quando você usa a keyword this em java, esta invocando o index 0 da Local Variable(aload_0) que aponta para a Constant Pool da sua classe.
Oque é executado dentro de uma STACK?
O primeiro método a ser executado dentro de um STACK é o método que vai no fim da STACK, no caso da thread main o método que vai ser executado é o main() no caso de uma outra thread o run(), isso significa que a vida da STACK é baseada no termino do método que esta no fim da Stack, e suas referencias a outras threads...(Por isso é chamado de Lifo, Primeiro a entrar, ultimo a sair.).
CLIQUE NA IMAGEM PARA MAXIMIZAR ELA
Processos:
- Basicamente um programa em execução -
Um processo é um container, que contem os recursos que ele terá em Runtime,e contem seu próprio espaço de memoria.Normalmente um processo é visto apenas como um programa ou um aplicativo em execução mais, oque o usuário vê como um simples Sistema pode de fato, ser um CONJUNTO DE PROCESSOS. PARA FACILITAR A COMUNICAÇÂO ENTRE PROCESSOS, GRANDE Parte do S.O garante o recurso de Inter Process Communication (IPC) COMO PIPES E SOCKETS.O IPC não é apenas para Processos no mesmo S.O, eles podem estar em DIFERENTES S.O.
Grande parte da Implementação da JVM, roda em um simples processo. Um Aplicativo java pode criar Processos adicionais, usando Objetos da classe java.lang.ProcessBuilder(This class is used to create operating system processes. ).
UM PROCESSO TEM AO MENOS UMA THREAD.
Um processo conhece o outro?
Não necessariamente, dependendo do SO, existem modos de um processo enviar msg para outro...Porem não necessariamente. CADA PROCESSO RODA INDEPENDENTE DO OUTRO...Mais eles podem cooperar entre si.
Oque é uma thread?
É a forma de um processo se dividir em uma ou mais "tarefas simultâneas"(ou seja é a forma de um processo se dividir em threads.).
São processos menos Pesados. Tanto threads quanto Processos te dão um ambiente de Execução, MAIS CRIAR UM NOVA THREAD, CONSOME MUITO MENOS DOQUE REALMENTE CRIAR UM NOVO PROCESSO.
threads existem dentro de um processo .Todo processo tem ao menos uma thread. threads dividem os recursos do processo , Incluindo Memoria e ARQUIVOS ABERTOS(fluxos).ISSO é muito eficiente, porem da muitos problemas de comunicação.
- Cada Thread é uma nova STACK -
Qual a diferença de thread e Thread?
Sabe-se que java é case-sensitive logo, thread = linha de execução, Thread = classe
Qual o tempo de resposta perceptivel ao ser Humano?
Cerca de 200 ms é o tempo que o ser Humano realmente consegue perceber algo.
Qual a tempo de resposta de troca de uma Stack de uma thread e outra?
Estima - se em 100 ms, porem eu andei avaliando esse tempo, e realmente depende da JVM, memoria etc, porem chega ate a ser 10x menor que isso!
Quantas threads um processo tem?
Ao menos uma, no caso de java, temos a thread main, que contem o main() que é o método que vai no fundo da Stack ou seja oque é executado pela jvm, quando o método no fundo da Stack termina o processo termina.
Como é thread x cpu?
Em hardwares com múltiplos CPUS ou múltiplos core, realmente existe simultaneidade entre as threads, porem em maquinas com apenas 1 core ou uma CPU, a troca de uma STACK para outra é tão rápida que parece que é simultâneo.
Oque é monoThread?
São os Sistemas que suportam apenas uma thread e os que suportam multiplas threads são chamado multiThreads.
Porque varias threads em um processo e não apenas vários processos?
O gasto para criação e troca de um processo para o outro é imensamente maior que a troca de uma thread para outra.Alem do tempo de resposta ser bem maior e o consumo de memoria em questões de thread também ser bem menor a comunicação entre threads é muito mais facil pois, trabalhamos em um nivel de abstração muito maior doque trabalhar com um processo.
Os processos dividem Oque?
Basicamente a CPU física, entre memoria etc.
Para quem o S.O entrega a CPU?
Quando estamos em um processo, O S.O. entrega a CPU para UMA THREAD DO PROCESSO.
Onde eu vejo os processos atuais em meu computador?
Cada S.O contem uma tabela de processos a qual o mesmo esta trabalhando no momento.
Oque é realmente ter múltiplas threads?
É como executar tarefas de duas listas. Nos ainda estaremos fazendo as tarefas em cada lista na ORDEM correta...Mais quando começamos a ficar entediados com as tarefas de uma lista, nos trocamos de lista...E futuramente quando voltarmos para fazer a lista que paramos, voltamos exatamente no mesmo ponto onde paramos.
(lista aqui pode ser Considerada um STACK)
Oque é Realmente um Sistema Operacional Multitarefa?
É aquele onde, consegue-se executar múltiplos programas ao mesmo tempo. Cada um desses programas tem AO MENOS 1 thread com eles. Os processos assim como as threads tem estado, e a thread do processo que não estiver sendo executada tem seu estado como “Sleeping”.
Outra definição:
São S.O.(s) que deixam múltiplos processos sendo executados em paralelo. Veja enquanto você esta no word, pode estar escutando musica, com o msn online etc. Claro que dependendo da quantidade de Cpus fisicas ou cores, a maioria desses processos fica em estado Sleeping.
Por onde começa a execução de um processo?
Todo processo tem um ponto de partida, o método que vai no fundo da Stack referente ao processo é aquele que é o ponto DE PARTIDA.(LIFO da Stack, ex: main() ).
Temos dois tipos de thread, KLT e ULT
Oque é KLT?
São Kernel-Level Thread. - Ou seja do S.O. -
Source: Java Threads, 2nd edition - Scott Oaks & Henry Wong -
Oque são ULT?
São User-Level Thread. - Ou seja do Usuário -
Quem suporta KLT?
O próprio S.O.
Quem suporta ULT?
A propria biblioteca da Linguagem que da suporte a ela.
Oque é Escalonador?
(Basicamente são Algoritmos escritos em uma linguagem de programação que gerencia quem deve usar a CPU no momento e por quanto tempo)
O escalonamento (ou agendador de tarefas) computacionais é uma atividade organizacional feita pelo escalonador (scheduler) da CPU ou de um Sistema Distribuído, possibilitando executar os processos(as threads, pois a CPU é entregue a uma thread de um processo) mais viáveis e concorrentes, priorizando determinados tipos de processos, como os de I/O Bound e os computacionalmente intensivos. O escalonador de processos de 2 níveis escolhe o processo que tem mais prioridade e menos tempo e coloca-o na memória principal, ficando os outros alocados em disco; com essa execução o processador evita ficar ocioso.
Quem é o Escalonador de java?
O escalonador de java depende muito da JVM em si, cuidado ao fazer programas multiThread e somente testar em uma JVM, o algoritmo escrito em java para JVM muitas vezes muda. Então se atente a isso.
Quem é o Escalonador do meu S.O?
Tudo dependerá do seu S.O. cada S.O tem o seu, no Caso do Linux o gerenciador de Memoria, processos etc é chamado de Kernel , que é um conjunto de SubSistemas e um deles é um GERENCIADOR DE PROCESSOS.Alguns S.O. como windows tem algoritmos de escalonamento como o Round-Robin.
Quem Escalona as ULT?
De uma modo geral é o programador, Porem o processo em si usa um Algortimo de escalonamento no caso de thread é o escalonador de processos que ajuda as threads a melhor se adptarem a situações.O S.O MUITAS VEZES NEM SABE DA EXISTENCIA DE "N" THREADS EM UM DETERMINADO PROCESSO.Neste modo o programador é responsável por criar, executar, escalonar e destruir a thread.QUANDO O S.O DA A CPU PARA UM PROCESSO, CABE AO PROCESSO DESTINAR QUAL SERÁ A THREAD QUE PRIMEIRO SERÁ EXECUTADA.
Quem Escalona as KLT?
O S.O elas são muito mais lentas que as ULT, cada chamada a uma KLT é uma consulta ao S.O. exigindo assim a mudança total de contexto do processador, memória e outros níveis necessários para alternar um processo.Primeira coisa, A CPU É dada a uma thread do processo e não ao processo, AS threads são independentes dos processos, eu posso estar no processo A1 thread A1A e ir para a thread A3A que é de outro processo, ou seja é a ordem que o escalonador determinar.Ja coma as Threds de ULT não temos essa independencia por o controle de threads é dado ao processo(ou seja o primeiro método que vai no fim da Stack, o main()) junto ao algoritmo em java do escalonador de threads.
Qual são os estados de um processo?
Clique na imagem para ampliar
Qual São os estados de uma thread?
Clique na imagem para ampliar
Nível de ABSTRAÇÃO ALTA, sobre a sucessão de passo ate um processo no S.O:
Basicamente quando você carrega um programa esse é manipulado por uma instancia da JVM, que faz as devidas manipulações, que vira processo no S.O, O gerenciamento de processos fica a encargo do S.O e o gerenciamento de threads fica ao encargo do escalonador da JVM. - Na maioria dos modelos de implementação da JVM
É hora da Revisão: - Revisão Válida apenas para threads Básico -
- A maioria dos Sistemas hoje em dia necessita de Concorrência(Simultaneidade) para que seu sistema faça mais de uma coisa "ao mesmo tempo".
- Softwares que conseguem fazer concorrência(Exemplo ler msg e enviar) são chamados de concurrent software.
- Existe uma API que foi inserida, a java.util.concurrent onde temos um alto nível de Simultaneidade.
- Se um computador tem apenas um processador, que não é multiProcessado, Apenas existe UMA THREAD de um processo sendo executado, apenas uma por vez.(um processador que não é multiProcessado Tem apenas 1 core.)
- O tempo de Processamento, é dividido entre todos os processos e todas as threads, e é chamado de time- slicing(fatia).
- Temos, Sistemas com Múltiplos processadores, ou processadores com múltiplos cores de Execução.
- Um Processo é um Programa em execução, cada Programa que você mandar executar em seu S.O. poderá ser visto na tabela de processos do S.O. e os processos tem estados assim como as threads.
- Sabemos que, todo processo tem ao menos uma thread,(vendo do ponto de vista de um programador) a thread main é a sua thread inicial, que te da o poder de criar novas threads.
- Threads Existem dentro de um processo.Todo processo tem ao menos uma thread. threads dividem os recursos do processo , Incluindo Memoria e ARQUIVOS ABERTOS(fluxos).ISSO é muito eficiente, porem da muitos problemas de comunicação.
-Existem threads do Sistema Operacional, e Existem threads da JVM e existem threads do seu processo. O S.O não conhece as threads do seu processo porque elas são encapsuladas pela JVM conseqüentemente o S.O só sabe que existe um processo com 1 thread, pois todo PROCESSO TEM AO MENOS UMA THREAD.
- Java Virtual Machine Stacks é muitas vezes referenciada somente COMO STACK
- Cada thread tem sua própria STACK
- Uma Stack é uma pilha que vamos empilhando Frames
- Toda Stack tem uma método que é o inicial, ou seja a primeira Frame a entrar na STACK(exemplo: o main())
- Um frame é criado toda vez que um método é invocado
- Um frame é destruido quando o code_block referente ao metodo terminou
- Cada Frame possui:
* Local Variable
* Operand Stack
* Uma Referencia a Runtime Constant Pool
- Quando um método é invocado, sobe uma Frame na Stack da thread.
- O Método que esta sendo executado em uma Stack, é o Frame que estiver no Topo da Stack, o Ultimo método que sera executado é o primeiro a ser colocado, ou seja...main(), run()...Quando um dos dois termina, a thread termina o seu code_block, Por isso a Stack é chamada de LIFO.
- Threads e simultaneidade é uma afirmação que muitas vezes foge da realidade, pois a maioria dos processadores são monoProcessador ou quando são multiCore, muitas das vezes um core já é usada por alguma função do S.O logo só temos uma disponível.(E o S.O. só entrega a Cpu para uma thread do processo, por isso da dificuldade de simultaneidade entre threads ou mesmo processos). - A troca de uma thread para a outra chega a ser bem inferior a 100 ms, a percepção humana é de 200 ms, logo aparenta-se simultaneidade. Para simultaneidade realmente ocorrer é necessário um processador físico multicore ou um multiprocessador. Assim como exemplo, Lado “A” do processador processa a thread 1, lado “B” do processador processa a thread 2.
- O escalonador do S.O. Entrega a CPU a uma thread do processo, sempre a uma thread.
- o PC do pc Register Aponta para o código sendo executado Referente a Frame da thread em questão, Se tivermos 2 threads , A e B, em troca de contexto (de thread) de A para B, A tem registrado no pc do PC Register qual a Instrução que devera fazer(ou seja uma depois daquela que ja fez), Quando o Scheduler volta de B para A, A volta exatamente onde tinha parado. - TROCA DE CONTEXTO PODE SER CONSIDERADO (TROCA DE THREAD) OU TAMBÉM TROCA DE STACK - O CÓDIGO SENDO EXECUTADO É APONTADO PELO PC do PC REGISTER DA METHOD AREA.
PC REGISTER e threads:
PS: Se 2 threads acessam o mesmo objeto, cada thread terá gravado no pc do pc Register em qual instrução está.
Thread A
Iconst_4
iconst_3 ← Oi eu so o pc do PC register e a thread A, esta aqui(iconst_4 ja foi resolvido)
iadd
Thread B
Iconst_4 ← Oi eu so o pc do PC register e a thread B, esta aqui(instrução n foi feita aind)
iconst_3
iadd
- LEMBRE-SE o pc do PC register guarda a próxima instrução que terá que fazer, exemplo, se ele ja fez iconst_4 ele vai apontar para iconst_3
Agora Ficou obviou que quando você tenta executar um class File que não contenha o main(), não faz o minimo sentido, já que é o método que é primeiro colocado no LIFO(Stack), ou seja é o primeiro a ser executado, e o Ultimo a terminar. Quando o main() é executado, sobe-se a Frame referente a ele.
Olhando em níveis bem abstratos e deixando detalhes de lado.
1 – Você escreve um algoritmo em uma linguagem de programação
2 – Você compila esse seu programa gerando um Class File
3 – Quando você usa o launcher de java( java identifier) para executar o seu programa, Na arquitetura da instancia da Jvm, cada thread do seu programa, ganhará uma:
*Program Counter Register
*Stack
* Native Method Stacks
4 – Na visão da Stack, o primeiro método executado da thread é o main() ou o run(), quando ele for invocado por uma instancia da JVM, a Stack da thread ganhará um frame que é devidamente de um desses métodos.
5 – A Constant Pool referente a cada Class File é mapeada para a Runtime Constant Pool da Method Area.
5 – o pc do Program Counter Register apontará para os bytecodes na Method Area,se for necessário resolver alguma constant é feito Dynamic Linking usando as informações já mapeadas da Runtime Constant Pool.
Isso é um ciclo extenso, foi muito abrevido pelo oque realmente eu achei importante até agora para um bom entendimento do porque de muita coisa, esse ciclo é chamado:loading, linking, initialization, and unloading
Bom por enquanto a postagem é essa, espero velos na próxima. Estamos perto de começar a instanciar objetos threads.
CYA DUDES!!!
Nenhum comentário:
Postar um comentário