Un processus est un programme autonome qui dispose de sa propre zone mémoire et est en compétition pour le processeur, tout comme les processus systèmes qui sont gérés par l'OS.

Un thread est un processus léger (morceau semi-autonome). Il ne dispose pas de sa propre zone mémoire, il n'est en compétition qu'avec les autres threads du programme parent. Les threads d'un programme se partagent le temps processeur aloué au programme parent. Voir la classe Thread dans la JavaDoc Voir autre cours ici.

Par héritage de la classe Thread :

class MaThread extends Thread
{
    int f( ) { ... }
    public void run( ) { //Code de la thread ... }
}
 
class TestMaThread
{
    public static void main( )
    {
        MaThread mt = new MaThread( );
        mt.f( );
        mt.start( ); //lance la Thread
        //exécuté en parallèle avec mt
    }    
}

Par héritage de l'interface Runnable

class MaThread implements Runnable
{
    int f( ) { ... }
    public void run( ) { //Code de la thread...}
}
 
class TestMaThread
{
    public static void main( )
    {
        MaThread mt = new MaThread( );
        Thread t = new Thread(mt);
        t.start( ); //lance la thread
    }
}

class MaThread implements Runnable
{
	private Thread t;
	private String name;
 
	public void run()
	{
		while(true)
			System.out.println(name);
	}
 
	public void setName(String name)
	{
		this.name = name;
	}
 
	public static void main(String arg[])
	{
		Thread t;
		MaThread mt[] = new MaThread[3];
		for(int i=0; i<3; i++)
		{
			mt[i] = new MaThread();
			mt[i].setName(Integer.toString(i));
			t = new Thread(mt[i]);
			t.start();
		}
		while(true)
			System.out.println("Main");
	}
}

Régles :

• entre 2 threads de priorités différentes, la thread de plus grande priorité est toujours prioritaire
• entre 2 threads de priorité identique, chaque JVM fait comme elle veut (FIFO, temps partagé, …

Notes : setPriority( … ) permet de fixer la priorité de la thread. yield( ) rend le processeur volontairement.

Lorsqu'il y a manipulation de variable commune entre les threads, il y a problème car un thread peut etre en train de modifier une variable alors qu'un autre thread tente la meme action. On utilisera donc le sémaphore. P( ) → entrer en section critique V( ) → sortir de la section critique

int i=0;
Semaphore s
Thread1 
s.P( );
i=i+1;
s.V( );

L'utilisation d'un sémaphore crée une file d'attente contenant la liste des threads voulant accéder à la section critique. En Java

public synchronized void f( )
{
   ...
}
<=>
void f( )
{
    this.P( )
    ...
    this.V( )
}