1. O conceito de processo e tópico
(1) Nos sistemas operacionais tradicionais, os programas não podem ser executados de forma independente e, como as unidades básicas de alocação de recursos e operação independente são todos processos.
Em sistemas sem SO, o método de execução dos programas é a execução seqüencial, ou seja, um programa deve ser executado antes que outro programa possa ser executado; Em um ambiente de vários programas, vários programas podem ser executados simultaneamente. Existem diferenças significativas entre as duas maneiras de execução de um programa. É precisamente essa característica da execução simultânea de programas que leva à introdução do conceito de processos no sistema operacional.
Como as pessoas propuseram o conceito de processos na década de 1960, os processos sempre foram usados no sistema operacional como a unidade básica que pode ter recursos e funcionar de forma independente. Até meados da década de 1980, as pessoas propuseram uma unidade básica que pode ser executada de forma independente, threads, que é menor que os processos, para tentar usá-lo para aumentar o grau de execução simultânea dos programas dentro do sistema, aumentando ainda mais a taxa de transferência do sistema. Especialmente depois de entrar na década de 1990, os sistemas multiprocessadores se desenvolveram rapidamente. Os threads podem melhorar melhor a execução paralela dos programas do que os processos e exercer completamente as vantagens dos multiprocessadores. Portanto, os threads foram introduzidos no sistema operacional multiprocessador lançado nos últimos anos para melhorar o desempenho do sistema operacional.
“O acima é extraído do " Sistema Operacional de Computadores - editado por Tang Xiaodan e outros - Edição 3 " (endereço de download)
(2) A figura a seguir é uma explicação dos usuários de Zhihu:
Através do entendimento geral acima, basicamente sabemos o que os tópicos e processos fazem. Então, vamos resumir o conceito de processos e tópicos abaixo:
(3) O processo é uma atividade em execução de um programa em um computador sobre um determinado conjunto de dados, é a unidade básica da alocação e programação de recursos do sistema e é a base da estrutura do sistema operacional. Nas estruturas iniciais de computadores orientadas ao processo, os processos foram as entidades básicas de execução dos programas; Nas estruturas contemporâneas de computador orientadas a roscas, os processos eram recipientes de threads. Um programa é uma descrição de instruções, dados e seu formulário organizacional, e um processo é uma entidade de um programa.
(4) Os threads, às vezes chamados de processos leves (LWP), são a menor unidade de fluxo de execução do programa. Os threads são um único processo de controle seqüencial em um programa. Uma unidade de execução relativamente independente e programável no processo é a unidade básica de agendamento independente e despacho CPU no sistema, que se refere à unidade de programação de programas de execução. Executando vários threads simultaneamente em um único programa para concluir trabalhos diferentes, chamados multithreading.
(5) A relação entre processo e thread:
2. Java implementa o método de múltiplos threading
(1) Herite o thread e reescreva o método run ()
classe pública mythread estende thread {@Override public void run () {while (true) {System.out.println (this.currentThread (). getName ()); }} public static void main (string [] args) {mythread thread = new mythread (); thread.start (); // A maneira correta de iniciar o thread}}Resultado da saída:
Thread-0Thread-0Thread-0 ...
Além disso, você precisa entender que o método start () é o método start () em vez do método run (). Se o método run () for usado, é um método comum para executar.
(2) Implementar a interface executável
public class MyRunnable implementa Runnable {@Override public void run () {System.out.println ("123"); } public static void main (string [] args) {myRunnable myRunnable = new MyRunnable (); Thread Thread = novo thread (MyRunnable, "T1"); thread.start (); }}3. Segurança da linha
Conceito de segurança do thread: quando vários threads acessarem uma determinada classe (objeto ou método), a classe sempre pode mostrar o comportamento correto e, em seguida, essa classe (objeto ou método) é segura por threads.
A segurança do thread é ao acessar multi-threads, um mecanismo de travamento é adotado. Quando um thread acessa alguns dados da classe, ele é protegido. Outros threads não podem acessá -lo até que o thread termine de lê -lo e outros threads não podem usá -lo. Não haverá inconsistência de dados ou poluição dos dados. Os threads não são seguros, o que significa que a proteção de acesso a dados não é fornecida. É possível que vários threads possam alterar os dados um após o outro, resultando nos dados resultantes estarem sujos. O mecanismo de travamento comum aqui é: sincronizado
4. Modificador sincronizado
(1) Sincronizado: Você pode adicionar bloqueios a qualquer objeto e método, e o código bloqueado é chamado de "área mutex" ou "área crítica".
(2) ** Não use ** instância sincronizada (código A):
public classe mythread estende o thread {private int conting = 5; @Override public void run () {count-; system.out.println (this.currentThread (). getName () + "count:" + count);} public static void main (string [] args) {mythreadReAD =, mythThThThThThThTh1; Thread (mythread, "Thread2"); Thread3 = novo Thread (mythread, "Thread3"); Thread Thread4 = novo Thread (mythread, "Thread4"); Thread5 = novo Thread (mythread, "Thread5"); Thread1.start ();Um resultado da saída é o seguinte:
Thread3 Contagem: 2THREAD4 CONTA: 1THREAD1 CONTA: 2THREAD2 CONTA: 3THREAD5 CONTA: 0
Pode -se observar que o resultado acima está incorreto, porque vários threads operam o método run () ao mesmo tempo e modificam a contagem, o que, por sua vez, causa um erro.
(3) ** Use a instância sincronizada (código B):
public class mythread estende thread {private int count = 5; @Override public sincronizado void run () {count--; System.out.println (this.currentThread (). GetName () + "count:" + count); } public static void main (string [] args) {mythread mythread = new mythread (); Thread Thread1 = novo thread (mythread, "Thread1"); Thread Thread2 = novo thread (mythread, "Thread2"); Thread Thread3 = novo thread (mythread, "Thread3"); Thread Thread4 = novo thread (mythread, "Thread4"); Thread Thread5 = novo thread (mythread, "Thread5"); Thread1.start (); Thread2.start (); thread3.start (); thread4.start (); thread5.start (); }}Resultado da saída:
Thread1 contagem: 4Thread2 contagem: 3Thread3 contagem: 2thread5 contagem: 1Thread4 contagem: 0
Pode -se observar que a diferença entre o código A e o código B é que a modificação sincronizada é adicionada ao método run ().
A descrição é a seguinte:
Quando vários threads acessarem o método de execução do mythread, se a modificação sincronizada for usada, o multi-thread será processado em uma fila (a fila aqui é determinada de acordo com a ordem da alocação da CPU). Se um thread desejar executar o código no método de modificação sincronizado, ele primeiro tentará obter o bloqueio. Se obtiver o bloqueio, execute o conteúdo do corpo de código sincronizado. Se não conseguir obter a fechadura, o encadeamento continuará tentando obter a fechadura até que ela o obtivesse. Além disso, vários threads competem pelo bloqueio ao mesmo tempo, o que significa que a concorrência de bloqueio ocorrerá.
5. Um objeto tem uma fechadura! Vários tópicos e vários bloqueios!
O que é, um objeto tem um bloqueio, vários threads têm vários bloqueios! Primeiro, vamos dar uma olhada no código de exemplo abaixo (código c):
classe pública multithread {private int num = 200; public sincronizado void printnum (string threadName, string tag) {if (tag.equals ("a")) {num = num - 100; System.out.println (ThreadName + "Tag A, defina num Over!"); } else {num = num - 200; System.out.println (ThreadName + "Tag" + Tag + ", num =" + num); } public static void main (string [] args) lança interruptedException {final multithread multithread1 = new Multithread (); Final Multithread multithread2 = new Multithread (); novo thread (novo runnable () {public void run () {multithread1.printnum ("Thread1", "A");}}). start (); Thread.sleep (5000); System.out.println ("Aguarde 5 segundos para garantir que o Thread1 tenha sido executado!"); novo thread (novo runnable () {public void run () {multithread2.printnum ("Thread2", "b");}}). start (); }}Resultado da saída:
Thread1 Tag a, defina num over! Thread1 tag a, num = 100Wait 5 segundos para garantir que o Thread1 tenha sido executado! thread2 tag b, defina num over! thread2 tag b, num = 0
Pode -se observar que existem dois objetos: Multithread1 e Multithread2. Se vários objetos usarem o mesmo bloqueio, o resultado da execução acima deve ser: thread2 tag b, num = -100. Portanto, cada objeto tem a trava desse objeto.
Os bloqueios obtidos pela palavra -chave sincronizados são bloqueios de objetos, em vez de tratar um pedaço de código ou método como bloqueios. Portanto, no código de exemplo acima, que primeiro executa o método de palavra -chave sincronizado, o encadeamento mantém a trava do objeto ao qual o método pertence. A rosca obtém dois bloqueios diferentes de dois objetos diferentes e eles se complementam.
Então, em cenários normais, deve haver uma situação em que todos os objetos operem em uma contagem variável, então como implementá -lo? É muito simples adicionar estático. Sabemos que todos os objetos nesta classe têm a mesma referência, não importa quantos objetos sejam instantados, a chamada é um método e o código é o seguinte (código d):
classe pública multithread {private static int num = 200; public static sincronizado void printnum (string threadName, string tag) {if (tag.equals ("a")) {num = num - 100; System.out.println (ThreadName + "Tag A, defina num Over!"); } else {num = num - 200; System.out.println (ThreadName + "Tag B, defina num Over!"); } System.out.println (ThreadName + "Tag" + Tag + ", num =" + num); } public static void main (string [] args) lança interruptedException {final multithread multithread1 = new Multithread (); Final Multithread multithread2 = new Multithread (); novo thread (novo runnable () {public void run () {multithread1.printnum ("Thread1", "A");}}). start (); Thread.sleep (5000); System.out.println ("Aguarde 5 segundos para garantir que o Thread1 tenha sido executado!"); novo thread (novo runnable () {public void run () {multithread2.printnum ("Thread2", "b");}}). start (); }}Resultado da saída:
Thread1 Tag a, defina num over! Thread1 tag a, num = 100Wait 5 segundos para garantir que o Thread1 tenha sido executado! thread2 tag b, defina num over! thread2 tag b, num = -100
Pode -se observar que a adição de modificação estática a variáveis e métodos pode realizar os cenários de que precisamos. Também mostra que, para métodos ou variáveis de modificação estática não estática, um objeto bloqueado.
6. Bloqueios de objetos síncronos e assíncronos
(1) sincronizado
O conceito de sincronização está compartilhando. Precisamos saber que a palavra "compartilhamento" não é um recurso compartilhado, não há necessidade de sincronizar, ou seja, não há necessidade de travá -lo;
O objetivo da sincronização é garantir a segurança dos threads. De fato, para a segurança dos threads, duas características mais básicas precisam ser atendidas: atomicidade e visibilidade;
(2) assincronizado: assincronizado
O conceito de assíncrono é a independência, sem restrições entre si, e não há relação entre os dois.
(3) Código de amostra:
public class myObject {public void method () {System.out.println (thread.currentThread (). getName ()); } public static void main (string [] args) {final myObject myObject = new myObject (); Thread t1 = new Thread (new Runnable () {public void run () {myObject.method ();}}, "t1"); Thread t2 = new Thread (new runnable () {public void run () {myObject.method ();}}, "t2"); t1.start (); t2.start (); }}No código acima, o método () é um método assíncrono.
Resumir
O exposto acima é o conteúdo inteiro deste artigo sobre a solução inicial para o conceito de encadeamento, processo e sincronizado no Java multi-threading. Espero que seja útil para todos. Se houver alguma falha, deixe uma mensagem e aponte -a, e o editor responderá a todos a tempo.