Qual é o significado do monitor de um objeto em Java? Por que usar essa palavra?

Ao ler artigos sobre encadeamentos Java, freqüentemente noto a expressão: "encadeamento atual é o proprietário do monitor deste objeto". Eu entendi o significado: o thread tem o direito de operar no objeto. Mas estou intrigado por que usamos a frase "o monitor do objeto" em vez de "o bloqueio do objeto".

Resumindo, não sei o significado da palavra 'monitor'. A pergunta pode ser estranha e simples. Mas gostaria que alguém pudesse ajudar a resolver isso. 3k

mas estou intrigado por que usar a palavra "monitor do objeto" em vez de "bloqueio do objeto"?

Consulte a resposta do ulmangt para links que explicam o termo "monitor" usado neste contexto. Observe que:

"Os monitores foram inventados por Per Brinch Hansen e CAR Hoare e foram implementados pela primeira vez na linguagem Concurrent Pascal de Brinch Hansen."

(Fonte: Wikipedia )

Por que usar o termo "monitorar" em vez de "bloquear"? Bem, estritamente falando, os termos significam coisas diferentes ... especialmente se você os usar da maneira que foram originalmente planejados para serem usados.

• Um "bloqueio" é algo com primitivas de aquisição e liberação que mantêm certas propriedades de bloqueio; por exemplo, uso exclusivo ou gravador único / leitor múltiplo.

• Um "monitor" é um mecanismo que garante que apenas um thread pode executar uma determinada seção (ou seções) de código a qualquer momento. Isso pode ser implementado usando um bloqueio (e "variáveis ​​de condição" que permitem que os encadeamentos aguardem ou enviem notificações para outros encadeamentos de que a condição foi cumprida), mas é mais do que apenas um bloqueio. De fato, no caso do Java, o bloqueio real usado por um monitor não está diretamente acessível. (Você simplesmente não pode dizer "Object.lock ()" para evitar que outros threads o adquiram ... como você pode com um JavaLock instância .)

Em suma, se alguém fosse pedante, "monitorar" é, na verdade, um termo melhor do que "trava" para caracterizar o que o Java está fornecendo. Mas, na prática, os dois termos são usados ​​quase que alternadamente.

Um monitor é simplesmente um termo para um objeto cujos métodos podem ser usados ​​com segurança em um ambiente multithread.

Há um ótimo artigo da Wikipedia sobre monitores:

http://en.wikipedia.org/wiki/Monitor_(synchronization)

Se você rolar para baixo, há até uma seção explicitamente sobre Java .

Citação de dentro da máquina virtual Java

Um encadeamento na máquina virtual Java solicita um bloqueio quando chega no início de uma região de monitor. Em Java, existem dois tipos de regiões de monitor: instruções sincronizadas e métodos sincronizados.

Monitor

Um monitor é como um edifício que contém uma sala especial que pode ser ocupada por apenas um fio de cada vez. A sala geralmente contém alguns dados. Desde o momento em que um thread entra nesta sala até o momento em que sai, ele tem acesso exclusivo a todos os dados na sala. Entrar no prédio do monitor é chamado de "entrar no monitor". Entrar na sala especial dentro do prédio é chamado de "adquirir o monitor". Ocupar a sala é chamado de "possuir o monitor" e sair da sala é chamado de "liberar o monitor". Sair de todo o prédio é chamado de "sair do monitor".

Além de ser associado a um bit de dados, um monitor é associado a um ou mais bits de código, que neste livro serão chamados de regiões de monitor.

Conforme mencionado anteriormente, a linguagem fornece duas maneiras integradas de identificar regiões de monitoramento em seus programas: instruções sincronizadas e métodos sincronizados. Esses dois mecanismos, que implementam o aspecto de exclusão mútua da sincronização, são suportados pelo conjunto de instruções da máquina virtual Java.

Fechadura

Para implementar a capacidade de exclusão mútua de monitores, a máquina virtual Java associa um bloqueio (às vezes chamado de mutex) a cada objeto e classe. Um bloqueio é como um privilégio que apenas um segmento pode "possuir" por vez.

Um único thread tem permissão para bloquear o mesmo objeto várias vezes. Para cada objeto, a máquina virtual Java mantém uma contagem do número de vezes que o objeto foi bloqueado. Um objeto desbloqueado tem uma contagem zero. Quando uma thread obtém o bloqueio pela primeira vez, a contagem é novamente incrementada para um. Cada vez que o thread adquire um bloqueio no mesmo objeto, a contagem é novamente incrementada.

Um synchronizedbloco ao redor de um objecté seu monitor, que controla o bloqueio do objeto. Aqui um exemplo

synchronized (object) {
   while (<condition does not hold>)
      object.wait(timeout);
   ... // Perform action appropriate to condition
}

Mesmo que seja tarde para responder a essa pergunta, pensei em apenas acrescentar, caso seja útil.
Aqui está um bloco sincronizado de código Java dentro de um método Java não sincronizado

public void add(int value){
synchronized(this){
      this.count += value;
   }
}

No exemplo, "this" é usado, que é a instância em que o método add é chamado. Um método de instância sincronizada usa o objeto ao qual pertence como objeto de monitor.
=> Apenas um thread pode ser executado dentro de um bloco de código Java sincronizado no mesmo objeto de monitor.

A Java Virtual Machine usa monitores para oferecer suporte a multithreading. Os monitores conseguem isso por meio de dois conceitos - exclusão mútua durante a execução das threads (aqui é onde o 'bloqueio' entra em cena) e coordenação como um meio de comunicação entre threads (aqui é onde os métodos de espera e notificação do objeto entram em cena).

Ler a seguinte parte de "Inside JVM" irá esclarecer esta dúvida, é muito bem explicado aqui (Capítulo 20, Sincronização de thread) -

https://www.artima.com/insidejvm/ed2/threadsynchP.html