Threads e variaveis

Duas threads podem percorrer o mesmo objeto, nesse caso, elas estarão compartilhando memórias e, por consequência, enviando dados umas para as outras.

Um exemplo simples:

public class ExemploThread {
    public static void main(String args[]) throws InterruptedException
    {
        //O código do main roda na thread principal.
        //Ainda na thread principal, vamos criar um contador.
        Contador c = new Contador(333);
        //Vamos criar uma segunda thread, para fazer esse contador girar.
        Thread threadContador = new Thread(c, "ThreadDoContador");
        threadContador.start();

        //Podemos fazer a main thread perguntar o valor do contador
        System.out.println("O contador está em:" + c.getNumero());
        
        //Vamos dormir alguns segundos, e deixar o contador rodar. E então
        //perguntar novamente o valor do contador.
        Thread.sleep(1476);
        System.out.println("O contador está em:" + c.getNumero());
        
        //De novo!
        Thread.sleep(1476);
        System.out.println("O contador está em:" + c.getNumero());

        //Agora vamos fazer a main thread pedir para o contador parar
        threadContador.interrupt();
        Thread.sleep(200);
        System.out.println("Programa finalizado!");        
    }
}

class Contador implements Runnable
{
    private long intervalo;
    private volatile int numero;

    public Contador(long intervalo)
    {
        this.intervalo = intervalo;
        this.numero = 0;
    }

    public void run() {
        try {
            while (!Thread.interrupted())
            {
                numero = numero + 1;
                Thread.sleep(intervalo);
            }
        } catch (InterruptedException e) {}
        System.out.println("Contador finalizado!");
    }

    public int getNumero() {
        return numero;
    }
}

Note que aqui a thread main se comunicou com a thread contadora, pois ambas conheciam o objeto Contador. A thread contadora estava percorrendo o Runnable, enquanto a thread main perguntava informações para esse Runnable. Seria possível também fazer a thread main usar sets no Runnable, que seriam vistos pela thread contadora.

Agora, quando threads se comunicam, é quando começa os problemas de se trabalhar com threads. É aqui que começa a se tornar importante conceitos como sincronização, semáforos e filas de mensagens.

Obrigado.
Fiquei chocado como era simples e eu não havia visto :shock:
O problema era que eu estava tentando criar varias threads da mesma class e não conseguia ver o modo de modificar o valor de apenas uma delas quando fosse necessário.
Não sei se fui claro na explicação, mas sua resposta resolveu meu problema, obrigado novamente.

Olha, toma cuidado com uma confusão comum entre os iniciantes de programação em threads.

Thread é a linha de execução. É o seu programa “rodando”.

A classe Thread apenas o disparador. Ela inicia a thread, e obtém informações sobre ela, mas não é a thread.

E o Runnable, é a apenas uma interface, que indica onde a thread começa.

O objeto que você monta sobre essa interface, também não é a thread. Duas threads podem, ao mesmo tempo, percorrer até mesmo o mesmo Runnable. Como é o caso do exemplo. A main thread poderá ler o valor da variável numero, ao mesmo tempo que a thread do contador está dormindo no método run.

Muitas confusões são evitadas quando esses conceitos estão bem separados.