Qual é a diferença entre um processo e um thread?

Qual é a diferença técnica entre um processo e um encadeamento?

Sinto que uma palavra como 'processo' é usada em excesso e também existem threads de hardware e software. Que tal processos leves em idiomas como Erlang ? Existe uma razão definitiva para usar um termo sobre o outro?

Os processos e os encadeamentos são sequências independentes de execução. A diferença típica é que os threads (do mesmo processo) são executados em um espaço de memória compartilhado, enquanto os processos são executados em espaços de memória separados.

Não tenho certeza a que threads de "hardware" vs "software" você pode estar se referindo. Threads são um recurso do ambiente operacional, em vez de um recurso da CPU (embora a CPU normalmente possua operações que tornam os threads eficientes).

Erlang usa o termo "processo" porque não expõe um modelo de multiprogramação de memória compartilhada. Chamá-los de "threads" implicaria que eles compartilhavam memória.

Processo
Cada processo fornece os recursos necessários para executar um programa. Um processo possui um espaço de endereço virtual, código executável, identificadores abertos para objetos do sistema, um contexto de segurança, um identificador de processo exclusivo, variáveis ​​de ambiente, uma classe de prioridade, tamanhos mínimo e máximo de conjuntos de trabalho e pelo menos um encadeamento de execução. Cada processo é iniciado com um único thread, geralmente chamado de thread primário, mas pode criar threads adicionais a partir de qualquer um de seus threads.

Encadeamento
Um encadeamento é uma entidade dentro de um processo que pode ser agendado para execução. Todos os threads de um processo compartilham seu espaço de endereço virtual e recursos do sistema. Além disso, cada encadeamento mantém manipuladores de exceção, uma prioridade de agendamento, armazenamento local de encadeamentos, um identificador de encadeamento exclusivo e um conjunto de estruturas que o sistema usará para salvar o contexto do encadeamento até que seja agendado. O contexto do encadeamento inclui o conjunto de registros de máquinas do encadeamento, a pilha do kernel, um bloco do ambiente do encadeamento e uma pilha do usuário no espaço de endereço do processo do encadeamento. Os threads também podem ter seu próprio contexto de segurança, que pode ser usado para representar clientes.

Esta informação foi encontrada no Microsoft Docs aqui: Sobre processos e threads

O Microsoft Windows suporta multitarefa preventiva, o que cria o efeito da execução simultânea de vários threads de vários processos. Em um computador com multiprocessador, o sistema pode executar simultaneamente quantos threads houver processadores no computador.

Processo:

• Uma instância de execução de um programa é chamada de processo.
• Alguns sistemas operacionais usam o termo 'tarefa' para se referir a um programa que está sendo executado.
• Um processo é sempre armazenado na memória principal, também denominada memória primária ou memória de acesso aleatório.
• Portanto, um processo é denominado como uma entidade ativa. Ele desaparece se a máquina for reiniciada.
• Vários processos podem estar associados a um mesmo programa.
• Em um sistema multiprocessador, vários processos podem ser executados em paralelo.
• Em um sistema de processador único, embora o verdadeiro paralelismo não seja alcançado, um algoritmo de agendamento de processos é aplicado e o processador é programado para executar cada processo, um de cada vez, produzindo uma ilusão de simultaneidade.
• Exemplo: Executando várias instâncias do programa 'Calculadora'. Cada uma das instâncias é denominada como um processo.

Fio:

• Um encadeamento é um subconjunto do processo.
• É denominado como um 'processo leve', pois é semelhante a um processo real, mas é executado no contexto de um processo e compartilha os mesmos recursos alocados ao processo pelo kernel.
• Normalmente, um processo tem apenas um segmento de controle - um conjunto de instruções da máquina sendo executadas por vez.
• Um processo também pode ser composto de vários segmentos de execução que executam instruções simultaneamente.
• Vários encadeamentos de controle podem explorar o verdadeiro paralelismo possível em sistemas multiprocessadores.
• Em um sistema de processador único, um algoritmo de agendamento de encadeamento é aplicado e o processador está agendado para executar cada encadeamento, um de cada vez.
• Todos os threads em execução em um processo compartilham o mesmo espaço de endereço, descritores de arquivo, pilha e outros atributos relacionados ao processo.
• Como os encadeamentos de um processo compartilham a mesma memória, a sincronização do acesso aos dados compartilhados no processo ganha uma importância sem precedentes.

Peguei emprestada as informações acima da Knowledge Quest! blog .

Primeiro, vamos olhar para o aspecto teórico. Você precisa entender o que é um processo conceitualmente para entender a diferença entre um processo e um encadeamento e o que é compartilhado entre eles.

Temos o seguinte na seção 2.2.2 O modelo de encadeamento clássico em sistemas operacionais modernos 3e de Tanenbaum:

O modelo de processo é baseado em dois conceitos independentes: agrupamento e execução de recursos. Às vezes é útil separá-los; é aqui que entram os tópicos ....

Ele continua:

Uma maneira de ver um processo é que é uma maneira de agrupar recursos relacionados. Um processo possui um espaço de endereço que contém texto e dados do programa, além de outros recursos. Esses recursos podem incluir arquivos abertos, processos filhos, alarmes pendentes, manipuladores de sinais, informações contábeis e muito mais. Reunindo-os na forma de um processo, eles podem ser gerenciados mais facilmente. O outro conceito de um processo é um encadeamento de execução, geralmente encurtado para apenas encadeamento. O encadeamento possui um contador de programa que controla qual instrução executar a seguir. Possui registradores, que mantêm suas variáveis ​​de trabalho atuais. Ele possui uma pilha, que contém o histórico de execução, com um quadro para cada procedimento chamado, mas ainda não retornado. Embora um encadeamento precise ser executado em algum processo, o encadeamento e seu processo são conceitos diferentes e podem ser tratados separadamente. Os processos são usados ​​para agrupar recursos; threads são as entidades agendadas para execução na CPU.

Mais abaixo, ele fornece a seguinte tabela:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

Vamos lidar com o problema de multithreading de hardware . Classicamente, uma CPU suporta um único thread de execução, mantendo o estado do thread por meio de um único contador de programa e conjunto de registros. Mas o que acontece se houver uma falta de cache? Leva muito tempo para buscar dados da memória principal e, enquanto isso acontece, a CPU fica parada lá ociosa. Então, alguém teve a ideia de basicamente ter dois conjuntos de estados de encadeamentos (PC + registradores) para que outro encadeamento (talvez no mesmo processo, talvez em um processo diferente) possa realizar o trabalho enquanto o outro encadeamento aguarda na memória principal. Existem vários nomes e implementações desse conceito, como HyperThreading e Simultaneous Multithreading (SMT, abreviado).

Agora vamos olhar para o lado do software. Existem basicamente três maneiras pelas quais os threads podem ser implementados no lado do software.

1. Tópicos no espaço do usuário
2. Tópicos do Kernel
3. Uma combinação dos dois

Tudo o que você precisa para implementar threads é a capacidade de salvar o estado da CPU e manter várias pilhas, o que em muitos casos pode ser feito no espaço do usuário. A vantagem dos encadeamentos de espaço do usuário é a troca de encadeamento super rápida, pois você não precisa interceptar o kernel e a capacidade de agendar seus encadeamentos da maneira que desejar. A maior desvantagem é a incapacidade de bloquear E / S (o que bloquearia todo o processo e todos os threads do usuário), que é um dos grandes motivos pelos quais usamos threads em primeiro lugar. O bloqueio de E / S usando threads simplifica bastante o design do programa em muitos casos.

Os threads do kernel têm a vantagem de poder usar E / S de bloqueio, além de deixar todos os problemas de agendamento para o sistema operacional. Mas cada opção de encadeamento requer interceptação no kernel, o que é potencialmente relativamente lento. No entanto, se você estiver alternando threads por causa de E / S bloqueada, isso não é realmente um problema, pois a operação de E / S provavelmente o prendeu no kernel de qualquer maneira.

Outra abordagem é combinar os dois, com vários threads do kernel, cada um com vários threads do usuário.

Então, voltando à sua questão de terminologia, você pode ver que um processo e um encadeamento de execução são dois conceitos diferentes e sua escolha de qual termo usar depende do que você está falando. Em relação ao termo "processo leve", eu pessoalmente não entendo o ponto, pois ele realmente não transmite o que está acontecendo, bem como o termo "thread de execução".

Para explicar mais com respeito à programação simultânea

1. Um processo possui um ambiente de execução independente. Um processo geralmente possui um conjunto completo e privado de recursos básicos em tempo de execução; em particular, cada processo possui seu próprio espaço de memória.

2. Os encadeamentos existem dentro de um processo - todo processo possui pelo menos um. Os threads compartilham os recursos do processo, incluindo memória e arquivos abertos. Isso cria uma comunicação eficiente, mas potencialmente problemática.

Mantendo a pessoa comum em mente,

No seu computador, abra o Microsoft Word e o navegador da web. Chamamos esses dois processos .

No Microsoft word, você digita alguma coisa e ela é salva automaticamente. Agora, você teria observado que a edição e o salvamento acontecem em paralelo - a edição em um thread e o salvamento no outro segmento.

Um aplicativo consiste em um ou mais processos. Um processo, nos termos mais simples, é um programa em execução. Um ou mais encadeamentos são executados no contexto do processo. Um encadeamento é a unidade básica à qual o sistema operacional aloca tempo do processador. Um encadeamento pode executar qualquer parte do código do processo, incluindo partes atualmente sendo executadas por outro encadeamento. Uma fibra é uma unidade de execução que deve ser agendada manualmente pelo aplicativo. As fibras são executadas no contexto dos segmentos que os agendam.

Roubado daqui .

Um processo é uma coleção de código, memória, dados e outros recursos. Um encadeamento é uma sequência de código que é executada no escopo do processo. Você pode (normalmente) ter vários threads executando simultaneamente no mesmo processo.

Exemplo do mundo real para processo e encadeamento Isso fornecerá a idéia básica sobre encadeamento e processo

Peguei emprestada a informação acima da resposta de Scott Langham - obrigado

Processo:

1. Processo é um processo pesado.
2. Process é um programa separado que possui memória, dados e recursos separados.
3. Os processos são criados usando o método fork ().
4. A troca de contexto entre o processo é demorada.
   

Exemplo:
digamos, abrindo qualquer navegador (mozilla, Chrome, IE). Nesse ponto, um novo processo começará a ser executado.

Tópicos:

1. Os threads são processos leves. Os threads são agrupados dentro do processo.
2. Os threads têm uma memória compartilhada, dados, recursos, arquivos etc.
3. Threads são criados usando o método clone ().
4. A troca de contexto entre os segmentos não consome muito tempo como Process.
   

Exemplo:
Abrindo várias guias no navegador.

• Todo processo é um thread (thread primário).
• Mas cada thread não é um processo. É uma parte (entidade) de um processo.

Tanto os threads quanto os processos são unidades atômicas de alocação de recursos do SO (ou seja, existe um modelo de simultaneidade que descreve como o tempo da CPU é dividido entre eles e o modelo de propriedade de outros recursos do SO). Há uma diferença em:

• Recursos compartilhados (os threads estão compartilhando memória por definição, eles não possuem nada, exceto pilha e variáveis ​​locais; os processos também podem compartilhar memória, mas existe um mecanismo separado para isso, mantido pelo SO)
• Espaço de alocação (espaço do kernel para processos vs. espaço do usuário para threads)

Greg Hewgill acima estava correto sobre o significado de Erlang da palavra "processo", e aqui há uma discussão sobre por que Erlang poderia fazer processos leves.

Os processos e os encadeamentos são sequências independentes de execução. A diferença típica é que os threads (do mesmo processo) são executados em um espaço de memória compartilhado, enquanto os processos são executados em espaços de memória separados.

Processo

É um programa em execução. possui seção de texto, ou seja, o código do programa, a atividade atual representada pelo valor do contador do programa e o conteúdo do registro dos processadores. Ele também inclui a pilha de processos que contém dados temporários (como parâmetros de função, variáveis ​​endereçadas e locais de retorno) e uma seção de dados, que contém variáveis ​​globais. Um processo também pode incluir um heap, que é a memória alocada dinamicamente durante o tempo de execução do processo.

Fio

Um encadeamento é uma unidade básica de utilização da CPU; compreende um ID de thread, um contador de programa, conjunto de registradores e uma pilha. compartilhou com outros threads pertencentes ao mesmo processo sua seção de código, seção de dados e outros recursos do sistema operacional, como arquivos e sinais abertos.

- Retirado do sistema operacional por Galvin

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

Linus Torvalds (torvalds@cs.helsinki.fi)

Ter, 6 de agosto de 1996 12:47:31 +0300 (EET DST)

Mensagens ordenadas por: [data] [tópico] [assunto] [autor]

Próxima mensagem: Bernd P. Ziller: "Re: Ops em get_hash_table"

Mensagem anterior: Linus Torvalds: "Re: pedido de solicitação de E / S"

Em segunda-feira, 5 de agosto de 1996, Peter P. Eiserloh escreveu:

Precisamos manter um conceito claro de threads. Muitas pessoas parecem confundir um segmento com um processo. A discussão a seguir não reflete o estado atual do linux, mas é uma tentativa de permanecer em uma discussão de alto nível.

NÃO!

Não há razão para pensar que "threads" e "processos" são entidades separadas. É assim que é feito tradicionalmente, mas eu pessoalmente acho que é um grande erro pensar dessa maneira. A única razão para pensar dessa maneira é a bagagem histórica.

Tanto os threads quanto os processos são realmente apenas uma coisa: um "contexto de execução". Tentar distinguir artificialmente diferentes casos é apenas autolimitado.

Um "contexto de execução", chamado COE, é apenas o conglomerado de todo o estado desse COE. Esse estado inclui coisas como estado da CPU (registros, etc.), estado da MMU (mapeamentos de páginas), estado de permissão (uid, gid) e vários "estados de comunicação" (arquivos abertos, manipuladores de sinais etc.). Tradicionalmente, a diferença entre um "encadeamento" e um "processo" é principalmente o fato de um encadeamento ter o estado da CPU (+ possivelmente algum outro estado mínimo), enquanto todo o outro contexto vem do processo. No entanto, essa é apenas uma maneira de dividir o estado total do COE, e não há nada que diga que é a maneira certa de fazê-lo. Limitar-se a esse tipo de imagem é simplesmente estúpido.

A forma como o Linux pensa sobre isso (e do jeito que eu quero que as coisas trabalho) é que não é nenhuma coisa como um "processo" ou um "thread". Existe apenas a totalidade do COE (chamado "tarefa" pelo Linux). Diferentes COEs podem compartilhar partes de seu contexto entre si, e um subconjunto desse compartilhamento é a configuração tradicional "thread" / "processo", mas isso realmente deve ser visto como APENAS um subconjunto (é um subconjunto importante, mas essa importância vem não do design, mas dos padrões: obviamente, também queremos executar programas de threads em conformidade com os padrões sobre o Linux).

Resumindo: NÃO projete de acordo com o modo de pensar do thread / processo. O kernel deve ser projetado com base na maneira de pensar do COE, e a biblioteca pthreads pode exportar a interface limitada do pthreads para usuários que desejam usar essa maneira de ver os COE.

Apenas como um exemplo do que se torna possível quando você pensa em COE em vez de encadear / processo:

• Você pode executar um programa externo "cd", algo que é tradicionalmente impossível no UNIX e / ou processo / thread (exemplo bobo, mas a idéia é que você pode ter esses tipos de "módulos" que não se limitam ao UNIX tradicional / instalação de threads). Faça um:

clone (CLONE_VM | CLONE_FS);

filho: execve ("cd externo");

/ * o "execve ()" desassociará a VM, portanto, o único motivo pelo qual usamos CLONE_VM foi tornar o ato de clonagem mais rápido * /

• Você pode executar o "vfork ()" naturalmente (ele atende ao suporte mínimo do kernel, mas esse suporte se encaixa perfeitamente na maneira de pensar da CUA):

clone (CLONE_VM);

filho: continue executando, eventualmente execve ()

mãe: aguarde execve

• você pode fazer "deamons de E / S" externos:

clone (CLONE_FILES);

filho: descritores de arquivo aberto etc

mãe: use os fd's que a criança abriu e vv.

Todas as opções acima funcionam porque você não está vinculado à maneira de pensar em threads / processos. Pense em um servidor da web, por exemplo, onde os scripts CGI são executados como "threads de execução". Você não pode fazer isso com os threads tradicionais, porque os threads tradicionais sempre precisam compartilhar todo o espaço de endereço; portanto, é necessário vincular tudo o que você sempre quis fazer no próprio servidor da Web (um "thread" não pode ser executado outro executável).

Pensando nisso como um problema de "contexto de execução", suas tarefas agora podem optar por executar programas externos (= separar o espaço de endereço do pai) etc, se quiserem, ou podem, por exemplo, compartilhar tudo com o pai, exceto por os descritores de arquivo (para que os sub- "threads" possam abrir muitos arquivos sem que o pai precise se preocupar com eles: eles fecham automaticamente quando o sub- "thread" sai e não usa fd no pai) .

Pense em um "inetd" encadeado, por exemplo. Você quer um overhead fork + exec baixo, portanto, com a maneira Linux, em vez de usar um "fork ()", você escreve um inetd multithread em que cada thread é criado apenas com CLONE_VM (compartilhe o espaço de endereço, mas não compartilhe o arquivo descritores etc). Em seguida, a criança pode executar se foi um serviço externo (rlogind, por exemplo), ou talvez tenha sido um dos serviços inetd internos (eco, horário do dia); nesse caso, apenas faz as coisas e sai.

Você não pode fazer isso com "thread" / "process".

Linus

Tentando responder a partir da exibição do SO do Linux Kernel

Um programa se torna um processo quando iniciado na memória. Um processo tem seu próprio espaço de endereço, o que significa ter vários segmentos na memória, como .textsegmento para armazenar código compilado, .bsspara armazenar variáveis ​​estáticas ou globais não inicializadas, etc.
Cada processo teria seu próprio contador de programa e pilha de espaço do usuário .

Dentro do kernel, cada processo teria sua própria pilha de kernel (que é separada da pilha de espaço do usuário por questões de segurança) e uma estrutura denominada task_structgeralmente abstraída como o bloco de controle do processo, armazenando todas as informações relacionadas ao processo, como sua prioridade, estado , (e muitas outras partes).
Um processo pode ter vários encadeamentos de execução.

Chegando aos threads, eles residem dentro de um processo e compartilham o espaço de endereço do processo pai, juntamente com outros recursos que podem ser transmitidos durante a criação do thread, como recursos do sistema de arquivos, compartilhamento de sinais pendentes, compartilhamento de dados (variáveis ​​e instruções), tornando os threads leves e permitindo, portanto, uma troca de contexto mais rápida.

Dentro do kernel, cada thread possui sua própria pilha de kernel junto com a task_structestrutura que define o thread. Portanto, o kernel exibe threads do mesmo processo que entidades diferentes e é agendável por si só. Os encadeamentos no mesmo processo compartilham um ID comum chamado como ID do grupo de encadeamentos ( tgid), também possuem um ID exclusivo chamado como o ID do processo ( pid).

Tentando responder a esta pergunta relacionada ao mundo Java.

Um processo é uma execução de um programa, mas um encadeamento é uma única sequência de execução dentro do processo. Um processo pode conter vários threads. Às vezes, um encadeamento é chamado de processo leve .

Por exemplo:

Exemplo 1: Uma JVM é executada em um único processo e os encadeamentos em uma JVM compartilham o heap pertencente a esse processo. É por isso que vários threads podem acessar o mesmo objeto. Os threads compartilham o heap e têm seu próprio espaço de pilha. É assim que a invocação de um método por um thread e suas variáveis ​​locais são mantidas em segurança contra outros threads. Mas o heap não é seguro para thread e deve ser sincronizado para segurança do thread.

Exemplo 2: Um programa pode não conseguir desenhar imagens, pressionando as teclas. O programa deve dar toda a atenção à entrada do teclado, e a falta de capacidade de lidar com mais de um evento por vez causará problemas. A solução ideal para esse problema é a execução contínua de duas ou mais seções de um programa ao mesmo tempo. Threads nos permite fazer isso. Aqui, a figura Desenho é um processo e a leitura das teclas é um subprocesso (thread).

Diferença entre Thread e Processo?

Um processo é uma instância de execução de um aplicativo e Um encadeamento é um caminho de execução dentro de um processo. Além disso, um processo pode conter vários threads. É importante observar que um thread pode fazer qualquer coisa que um processo possa fazer. Porém, como um processo pode consistir em vários threads, um thread pode ser considerado um processo 'leve'. Assim, a diferença essencial entre um encadeamento e um processo é o trabalho que cada um é usado para realizar. Os encadeamentos são usados ​​para tarefas pequenas, enquanto os processos são usados ​​para tarefas mais "pesadas" - basicamente a execução de aplicativos.

Outra diferença entre um encadeamento e um processo é que os encadeamentos no mesmo processo compartilham o mesmo espaço de endereço, enquanto processos diferentes não. Isso permite que os threads leiam e gravem nas mesmas estruturas e variáveis ​​de dados, além de facilitar a comunicação entre os threads. A comunicação entre processos - também conhecida como IPC, ou comunicação entre processos - é bastante difícil e consome muitos recursos.

Aqui está um resumo das diferenças entre threads e processos:

1. Os threads são mais fáceis de criar do que os processos, pois não requerem um espaço de endereço separado.

2. O multithreading requer uma programação cuidadosa, pois os threads compartilham estruturas de dados que devem ser modificadas apenas por um thread por vez. Diferentemente dos encadeamentos, os processos não compartilham o mesmo espaço de endereço.

3. Threads são considerados leves porque usam muito menos recursos que processos.

4. Os processos são independentes um do outro. Os encadeamentos, pois compartilham o mesmo espaço de endereço, são interdependentes; portanto, é necessário ter cuidado para que diferentes encadeamentos não se interajam.
   Esta é realmente outra maneira de afirmar o item 2 acima.

5. Um processo pode consistir em vários encadeamentos.

A seguir, é o que obtive de um dos artigos do The Code Project . Eu acho que explica tudo o que é necessário claramente.

Um encadeamento é outro mecanismo para dividir a carga de trabalho em fluxos de execução separados. Um segmento é mais leve que um processo. Isso significa que ele oferece menos flexibilidade do que um processo completo, mas pode ser iniciado mais rapidamente, pois o sistema operacional possui menos configurações. Quando um programa consiste em dois ou mais threads, todos os threads compartilham um único espaço de memória. Os processos recebem espaços de endereço separados. todos os threads compartilham uma única pilha. Mas cada thread recebe sua própria pilha.

Processo:

Processo é basicamente um programa em execução. É uma entidade ativa. Alguns sistemas operacionais usam o termo 'tarefa' para se referir a um programa que está sendo executado. Um processo é sempre armazenado na memória principal, também denominada memória primária ou memória de acesso aleatório. Portanto, um processo é denominado como uma entidade ativa. Ele desaparece se a máquina for reiniciada. Vários processos podem estar associados a um mesmo programa. Em um sistema multiprocessador, vários processos podem ser executados em paralelo. Em um sistema de processador único, embora o verdadeiro paralelismo não seja alcançado, um algoritmo de agendamento de processos é aplicado e o processador é programado para executar cada processo, um de cada vez, produzindo uma ilusão de simultaneidade. Exemplo: Executando várias instâncias do programa 'Calculadora'. Cada uma das instâncias é denominada como um processo.

Fio:

Um encadeamento é um subconjunto do processo. É denominado como um 'processo leve', pois é semelhante a um processo real, mas é executado no contexto de um processo e compartilha os mesmos recursos alocados ao processo pelo kernel. Normalmente, um processo tem apenas um segmento de controle - um conjunto de instruções da máquina sendo executadas por vez. Um processo também pode ser composto de vários encadeamentos de execução que executam instruções simultaneamente. Vários encadeamentos de controle podem explorar o verdadeiro paralelismo possível em sistemas multiprocessadores. Em um sistema de processador único, um algoritmo de agendamento de encadeamento é aplicado e o processador está agendado para executar cada encadeamento, um de cada vez. Todos os threads em execução em um processo compartilham o mesmo espaço de endereço, descritores de arquivo, pilha e outros atributos relacionados ao processo. Como os threads de um processo compartilham a mesma memória,

ref- https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

Do ponto de vista de um entrevistador, existem basicamente apenas três coisas principais que quero ouvir, além de coisas óbvias como um processo que pode ter vários tópicos:

1. Os threads compartilham o mesmo espaço de memória, o que significa que um thread pode acessar a memória da memória de threads de outras pessoas. Processos normalmente não podem.
2. Recursos. Os recursos (memória, identificadores, soquetes, etc.) são liberados no encerramento do processo, não no encerramento do thread.
3. Segurança. Um processo possui um token de segurança fixo. Um encadeamento, por outro lado, pode representar diferentes usuários / tokens.

Se você quiser mais, a resposta de Scott Langham cobre praticamente tudo. Tudo isso é da perspectiva de um sistema operacional. Linguagens diferentes podem implementar conceitos diferentes, como tarefas, threads leves, etc., mas são apenas maneiras de usar threads (de fibras no Windows). Não há threads de hardware e software. Há exceções e interrupções de hardware e software , ou threads de modo de usuário e kernel .

1. Um encadeamento é executado em um espaço de memória compartilhado, mas um processo é executado em um espaço de memória separado
2. Um encadeamento é um processo leve, mas um processo é pesado.
3. Um encadeamento é um subtipo de processo.

Para aqueles que estão mais à vontade com o aprendizado visualizando, aqui está um diagrama útil que eu criei para explicar Process e Threads.
Usei as informações do MSDN - Sobre processos e threads

Vindo do mundo incorporado, gostaria de acrescentar que o conceito de processos existe apenas em processadores "grandes" ( CPUs de desktop, ARM Cortex A-9 ) que possuem MMU (unidade de gerenciamento de memória) e sistemas operacionais compatíveis com o uso de MMUs ( como o Linux ). Com processadores e microcontroladores pequenos / antigos e pequeno sistema operacional RTOS (sistema operacional em tempo real ), como o freeRTOS, não há suporte para MMU e, portanto, não há processos, mas apenas threads.

Os threads podem acessar a memória uns dos outros e são agendados pelo sistema operacional de maneira intercalada, para que pareçam rodar em paralelo (ou com vários núcleos, eles realmente rodam em paralelo).

Os processos , por outro lado, vivem em sua caixa de proteção privada de memória virtual, fornecida e protegida pela MMU. Isso é útil porque permite:

1. mantendo o processo com erros de travar todo o sistema.
2. Manutenção da segurança, tornando os dados de outros processos invisíveis e inacessíveis. O trabalho real dentro do processo é realizado por um ou mais threads.

1. Basicamente, um encadeamento é parte de um processo sem o encadeamento do processo não capaz de funcionar.
2. Um segmento é leve, enquanto o processo é pesado.
3. a comunicação entre processos requer algum tempo, enquanto o encadeamento requer menos tempo.
4. Os threads podem compartilhar a mesma área de memória, enquanto o processo é separado.

Processo : o programa em execução é conhecido como processo

Thread : Thread é uma funcionalidade que é executada com a outra parte do programa, com base no conceito de "um com o outro", de modo que o thread faz parte do processo.

Pesquisei quase todas as respostas por lá, infelizmente, como um estudante de graduação que faz um curso de SO atualmente não consigo compreender completamente os dois conceitos. Quero dizer, a maioria dos caras lê em alguns livros do SO as diferenças, ou seja, os threads são capazes de acessar variáveis ​​globais na unidade de transação, uma vez que fazem uso do espaço de endereço do processo. No entanto, surge a nova pergunta: por que existem processos? Sabemos que já sabemos que os encadeamentos são mais leves em relação aos processos. Vamos dar uma olhada no exemplo a seguir, usando a imagem extraída de uma das respostas anteriores ,

Temos 3 threads trabalhando ao mesmo tempo em um documento do Word, por exemplo, Libre Office . O primeiro faz a verificação ortográfica, sublinhando se a palavra está incorreta. O segundo pega e imprime letras do teclado. E o último salva o documento em intervalos curtos para não perder o documento trabalhado se algo der errado. Nesse caso, os 3 threads não podem ser 3 processos, pois compartilham uma memória comum, que é o espaço de endereço do processo e, portanto, todos têm acesso ao documento que está sendo editado. Portanto, a estrada é o documento do Word, juntamente com duas escavadeiras, que são os tópicos, embora uma delas seja a falta na imagem.

Ao criar um algoritmo em Python (linguagem interpretada) que incorporava multi-threading, fiquei surpreso ao ver que o tempo de execução não era melhor quando comparado ao algoritmo sequencial que eu havia construído anteriormente. Em um esforço para entender a razão desse resultado, li e acredito que o que aprendi oferece um contexto interessante para entender melhor as diferenças entre multi-threading e multi-processos.

Os sistemas com vários núcleos podem exercer vários encadeamentos de execução e, portanto, o Python deve oferecer suporte a multiencadeamento. Mas Python não é uma linguagem compilada e, em vez disso, é uma linguagem interpretada ¹ . Isso significa que o programa deve ser interpretado para ser executado, e o intérprete não está ciente do programa antes de iniciar a execução. O que ele sabe, no entanto, são as regras do Python e depois as aplica dinamicamente. As otimizações no Python devem ser principalmente otimizações do próprio intérprete e não do código a ser executado. Isso contrasta com linguagens compiladas, como C ++, e tem conseqüências para multiencadeamento em Python. Especificamente, o Python usa o Global Interpreter Lock para gerenciar multi-threading.

Por outro lado, uma linguagem compilada é, bem, compilada. O programa é processado "inteiramente", onde primeiro é interpretado de acordo com suas definições sintáticas, depois mapeado para uma representação intermediária independente da linguagem e, finalmente, vinculado a um código executável. Esse processo permite que o código seja altamente otimizado porque está disponível no momento da compilação. As várias interações e relacionamentos do programa são definidas no momento em que o executável é criado e decisões robustas sobre otimização podem ser tomadas.

Nos ambientes modernos, o intérprete do Python deve permitir multiencadeamento, e isso deve ser seguro e eficiente. É aqui que a diferença entre ser uma linguagem interpretada versus uma linguagem compilada entra em cena. O intérprete não deve perturbar os dados compartilhados internamente de diferentes threads, enquanto otimiza o uso de processadores para cálculos.

Como foi observado nas postagens anteriores, um processo e um encadeamento são execuções seqüenciais independentes, com a principal diferença: a memória é compartilhada entre vários encadeamentos de um processo, enquanto os processos isolam seus espaços de memória.

No Python, os dados são protegidos contra acesso simultâneo por diferentes threads pelo Global Interpreter Lock. Requer que em qualquer programa Python apenas um thread possa ser executado a qualquer momento. Por outro lado, é possível executar vários processos, pois a memória de cada processo é isolada de qualquer outro processo, e os processos podem ser executados em vários núcleos.

¹ Donald Knuth tem uma boa explicação das rotinas interpretativas em A Arte da Programação por Computador: Algoritmos Fundamentais.

Threads dentro do mesmo processo compartilham a Memória, mas cada thread tem sua própria pilha e registradores, e os threads armazenam dados específicos do thread no heap. Os encadeamentos nunca são executados independentemente, portanto, a comunicação entre encadeamentos é muito mais rápida quando comparada à comunicação entre processos.

Os processos nunca compartilham a mesma memória. Quando um processo filho cria, ele duplica o local da memória do processo pai. A comunicação do processo é feita usando pipe, memória compartilhada e análise de mensagens. A alternância de contexto entre os threads é muito lenta.

A melhor resposta que encontrei até agora é 'The Linux Programming Interface' de Michael Kerrisk :

Nas implementações modernas do UNIX, cada processo pode ter vários encadeamentos de execução. Uma maneira de visualizar threads é como um conjunto de processos que compartilham a mesma memória virtual, além de vários outros atributos. Cada encadeamento está executando o mesmo código de programa e compartilha a mesma área de dados e heap. No entanto, cada encadeamento possui sua própria pilha contendo variáveis ​​locais e informações de ligação de chamada de função. [LPI 2.12]

Este livro é uma fonte de grande clareza; Julia Evans mencionou sua ajuda para esclarecer como os grupos Linux realmente funcionam neste artigo .

Exemplo 1: Uma JVM é executada em um único processo e os encadeamentos em uma JVM compartilham o heap pertencente a esse processo. É por isso que vários threads podem acessar o mesmo objeto. Os threads compartilham o heap e têm seu próprio espaço de pilha. É assim que a invocação de um método por um thread e suas variáveis ​​locais são mantidas em segurança contra outros threads. Mas o heap não é seguro para thread e deve ser sincronizado para segurança do thread.

Eles são quase os mesmos ... Mas a principal diferença é que um segmento é leve e um processo é pesado em termos de alternância de contexto, carga de trabalho e assim por diante.