Thread com comportamento inesperado

Você está confundindo as coisas.

A thread não é um objeto. A thread é a linha de execução.

Agora, eu te pergunto… qual foi a linha de execução que chamou o método wait()? Foi a da thread que estava rodando em paralelo, ou foi a do Swing? Foi a do Swing. Por isso, quem parou foi o Swing.

Para corrigir o seu código, a thread do Swing tem que simplesmente avisar a thread criada no start, para que ela mesmo chame o wait.

Como nesse caso (refatorei sua classe Runnable para ser usada no mesmo contexto anterior. Não testei esse código, mas a idéia básica é essa):

private class Rodavel implements Runnable{   
   private boolean pausa = false;

   public void run(){   
      while(true){   
         System.out.println("tick");   
         try {   
            Thread.sleep(500);   
            synchronized (this) {
               //O wait precisa estar associado a um while
               //senão há riscos de spurious wakeup.
               while (pausa)  //Testa continuamente essa variável, que pode ser alterada por outras threads.
                  wait();   
            }
         } catch (InterruptedException e) {}   
      }
   }   
                
   private synchronized void pausa() {
      pausa = true; //A thread do run logo irá ler essa variável, que será definida pela thread do swing. 
   }

   public synchronized void continua(){   
      pausa = false; //Avisa a thread do runnable que pode rodar
      notify();          //E pede para o SO a colocar em execução em algum momento no futuro.
   }   
}

Agora… imagine que tem uma thread rodando dentro do seu run… É um outro programinha, executando passo-a-passo, imprimindo tick, mas contido dentro daquele while. Esse programinha lê a variável pausa, a vai chamar o método wait se ela valer true.

Existe outro mini programa, que é o Swing, controlando ações do usuário. Ele vai lá e altera a variável pausa, que é a mesma que aquele programinha do run lê. Por isso dizemos que threads compartilham memória, já que a variável, no fundo, é um espaço de memória com um nome, visto por duas threads. A thread do run(), então, vai testar o novo valor de pausa e chamar o método wait().

Do jeito que você estava fazendo, a thread do Swing entra no método pausa() e chama o wait(). A thread do run() continua rodando normalmente, já que ela nem sequer chamou método nenhum.

Hum… agora fez mais sentido… obrigado pela resposta!

:roll:

Em que outro contexto eu posso usar o wait()? Eu sei que eu posso usar a tranca de outro objeto, por exemplo…

No famoso algoritmo do produtor/consumidor, por exemplo.

Imagine uma classe que contém uma fila. Uma thread lê dados dessa fila, outra coloca dados nessa fila.
Você pode usar o wait para fazer quem lê esperar ter elementos na fila, caso não tenha. E o notify() para o produtor avisar que um novo elemento foi colocado na fila.