Come dovrebbe essere l'approccio per iniziare a pensare alla programmazione multi-thread [chiuso]

Il modo più semplice è pensare ai thread come processi (e questo è il caso in alcuni sistemi unixy che generano un nuovo processo in cui alcuni sistemi creerebbero un nuovo thread).

Un processo è un blob di codice e dati con uno stack e un singolo thread comunque.

Una volta lì, puoi iniziare a immaginare di condividere i dati tra i thread: è più facile in un singolo processo con più thread, ma pericoloso. Pensare a ciascun thread come a un "processo" aiuterà a visualizzare l'importanza di comprendere dove vengono gestiti i dati condivisi.

Di solito penso al thread come una freccia che esegue il tuo codice (come quando esegui il debug su Eclipse o Netbeans);
Questa piccola freccia esegue il tuo codice, ma invece di averne uno solo ne spunterai un altro.

In Java, è necessario consentire a una classe di implementare l'interfaccia Runnable che consente di implementare il metodo run ();
Quando vuoi generare un nuovo thread che viene eseguito in parallelo rispetto al primo devi aprire un oggetto Thread, passare l'oggetto che implementa Runnable e avviarlo.

public class SaimLol implements Runnable {
    @Override
    public void run() {
        while(true) { 
            doSomethingInSaimLol();
        }
    }
}


public class Main {
    public static void main(String... args) {
        SaimLol myObject = new SaimLol();
        Thread threadSaim = new Thread(myObject);
        threadSaim.start();

        doSomethingInMain();
    }
}

Qual è l'obiettivo della programmazione del thread?
Quando si avvia il thread chiamando il threadSaim.start () una nuova "freccia" spawn e il codice verrà eseguito chiamando contemporaneamente i metodi doSomethingInSaimLol () e doSomethingInMain ();
Con i thread puoi fare cose come controllare due parti del tuo codice simultaneamente, o cose più avanzate come costruire un semaforo per far conoscere il primo thread se tutte le variabili sono settate e può andare.

Penso che il modo migliore per gestire la programmazione parallela sia tenere a mente i dati globali con cui hai a che fare e non tanto il codice su cui stai scrivendo. Non appena incappi in dati globali (come una variabile membro), devi pensare a te stesso: è possibile che questa variabile venga raggiunta da più thread?

Il vantaggio di questo approccio è che stai pensando a cosa è essenziale per il multithreading, ovvero accedere ai dati globali e non al tuo codice. Non importa quale codice sta accedendo; potrebbe essere il codice che stai attualmente digitando o un codice da qualche altra parte. Non penso se il mio codice verrà eseguito in parallelo, mi sto solo preoccupando della variabile che sto ricevendo.