Semaphore ! ne s'arrete jamais

**snipes** · 26/03/2008, 04h47

salut les amis

j'ai un soucis au niveau de mon code et je ne comprend pas d'ou peut provenir mon erreur
en fait j'ai créé 3 thread qui sont censé jongler avec le systeme de gestion de la concurrence mais le probleme c'est qu'ils se bloquent jamais
par exemple si j'ai une ressource a=1 et que le thread l'utilises , les autres sont censé attendre que le thread 1 finisse pour a leur tour utiliser la ressource mais ils ne se bloquent pas

voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
import java.util.concurrent.Semaphore;
 
 
public class MyThread extends Thread{	
 
	//public static int ProcId = 0;
	Semaphore Sem_Place;
	Semaphore Sem_Rampe;
	private static int place_nbr = 1;
	private static int rampe = 1;
 
	MyThread(){
 
		Sem_Place = new Semaphore(this.place_nbr,true);
		Sem_Rampe = new Semaphore(this.rampe,true);
 
	}
 
	public void run(){
 
		try {
			System.out.println("(Proc : "+this.getId()+") Veut rentrer dans le parking !");
			this.entrer_parking();
			System.out.println("(Proc : "+this.getId()+") Veut sortir du parking !");
			this.sortir_parking();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
 
	}
 
	public void entrer_parking() throws InterruptedException{
 
		Sem_Place.acquire();
		System.out.println("(Proc : "+this.getId()+") a donné sa carte");
		Sem_Rampe.acquire();
		System.out.println("(Proc : "+this.getId()+") passe sur la rampe");
		Sem_Rampe.release();
		System.out.println("(Proc : "+this.getId()+") est descendu de la rampe et est garé a sa place !");
	}
 
	public void sortir_parking() throws InterruptedException{
		Sem_Rampe.acquire();
		System.out.println("(Proc : "+this.getId()+") passe sur la rampe");
		Sem_Rampe.release();
		System.out.println("(Proc : "+this.getId()+") est descendu de la rampe");
		Sem_Place.release();
		System.out.println("(Proc : "+this.getId()+") est sortie du parking...Place liberée !");
	}
 
 
}

et mon main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
public class main {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
 
 
		MyThread P1 = new MyThread();
		MyThread P2 = new MyThread();
		MyThread P3 = new MyThread();
 
		P1.start();
		P2.start();
		P3.start();
 
	}
 
}

**divxdede** · 26/03/2008, 09h35

Ques-ce qui te fait dire qu'aucun thread n'a "attendu" lors d'un acquire ?

Tu peu essayer de remplacer tes "acquire" par des "tryAcquire" et voir si un thread retourne false.

Sinon, si ta plateforme est mono-core, il se peut également que tes threads s'execute finalement séquentiellement dans ton cas (car ils ont un code trés minimaliste) et tout dépends du scheduler.

**snipes** · 26/03/2008, 18h00

Ques-ce qui te fait dire qu'aucun thread n'a "attendu" lors d'un acquire ?

j'ai fait un truc du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
if(this.getId() == 8) 
     MyThread.sleep(10);

8 etant un numero de processus retourné
et aucun blocage constaté

sinon jsuis en dual core...

**divxdede** · 26/03/2008, 18h19

je ne comprends pas en quoi ce "sleep" t'indique que les méthodes acquire n'ont pas provoquées d'attentes ?

**snipes** · 26/03/2008, 19h05

comme je le fais apres acquire normalement la ressource est censé etre prise ?
donc ceux qui viennent apres ne attendent ?
dis moi si je me trompe

**divxdede** · 26/03/2008, 19h58

Chacun de tes threads possédent leurs propres sémaphores alors que ces derniers doivent être partagés entre les differents threads afin de servire de mécanismes de synchronisations.

**divxdede** · 26/03/2008, 20h02

Voici le code qui montre les sémaphores dans un environnements qui fonctionnent:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
 
 
public class Test {	
 
    private static class MyWorker implements Runnable {
 
        /** time to wait after acquiring a "rampe"
         */
        TimeUnit unit      = null;
        long     sleepTime = 0;
 
        /** Initial Available spaces
         */
	private static int NBR_PLACES = 1;
	private static int NBR_RAMPE  = 1;
 
        /** Semaphores
         */
	private static Semaphore semPlace = new Semaphore( NBR_PLACES , true );
	private static Semaphore semRampe = new Semaphore( NBR_RAMPE  , true );
 
        public MyWorker( long time , TimeUnit unit ) {
            this.unit = unit;
            this.sleepTime = time;
        }
 
        /** reference time
         */
        private static final long referenceTime = System.currentTimeMillis();
 
        private String getWorkerStamp() {
            return "[" + ( System.currentTimeMillis() - referenceTime ) + "] (Proc : " + Thread.currentThread().getId() + ")";
        }
 
	public void run(){
            try {
                    System.out.println( getWorkerStamp() + " veut rentrer dans le parking !");
                    this.entrer_parking();
                    System.out.println( getWorkerStamp() + " veut sortir du parking !");
                    this.sortir_parking();
            } catch (InterruptedException e) {
                    e.printStackTrace();
            }
 
	}
 
	public void entrer_parking() throws InterruptedException{
		try {
                    semPlace.acquire();
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
		System.out.println( getWorkerStamp()  + " a donné sa carte, ATTENTE");
                try {
                    this.unit.sleep( this.sleepTime );
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
                finally {
                    System.out.println( getWorkerStamp() + " a fini son attente");
                }
		semRampe.acquire();
		System.out.println( getWorkerStamp() + " passe sur la rampe");
		semRampe.release();
		System.out.println( getWorkerStamp() + " est descendu de la rampe et est garé a sa place !");
	}
 
	public void sortir_parking() throws InterruptedException{
		semRampe.acquire();
		System.out.println( getWorkerStamp() + " passe sur la rampe (pour sortir)");
		semRampe.release();
		System.out.println( getWorkerStamp() + " est descendu de la rampe (pour sortir)");
		semPlace.release();
		System.out.println( getWorkerStamp() + " est sorti du parking...Place liberée !");
	}
    }
 
    public static void main(String[] args) {
 
        Thread p1 = new Thread( new MyWorker( 4000 , TimeUnit.MILLISECONDS ) );
        Thread p2 = new Thread( new MyWorker( 500 , TimeUnit.MILLISECONDS ) );
        Thread p3 = new Thread( new MyWorker( 50 , TimeUnit.MILLISECONDS ) );
 
        p1.start();
        p2.start();
        p3.start();
 
    }
 
}

**divxdede** · 26/03/2008, 20h03

Voici la sortie que cela donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
[0] (Proc : 7) veut rentrer dans le parking !
[0] (Proc : 9) veut rentrer dans le parking !
[0] (Proc : 8) veut rentrer dans le parking !
[0] (Proc : 7) a donné sa carte, ATTENTE
[4000] (Proc : 7) a fini son attente
[4000] (Proc : 7) passe sur la rampe
[4000] (Proc : 7) est descendu de la rampe et est garé a sa place !
[4000] (Proc : 7) veut sortir du parking !
[4000] (Proc : 7) passe sur la rampe (pour sortir)
[4000] (Proc : 7) est descendu de la rampe (pour sortir)
[4000] (Proc : 7) est sorti du parking...Place liberée !
[4000] (Proc : 9) a donné sa carte, ATTENTE
[4047] (Proc : 9) a fini son attente
[4047] (Proc : 9) passe sur la rampe
[4047] (Proc : 9) est descendu de la rampe et est garé a sa place !
[4047] (Proc : 9) veut sortir du parking !
[4047] (Proc : 9) passe sur la rampe (pour sortir)
[4047] (Proc : 9) est descendu de la rampe (pour sortir)
[4047] (Proc : 9) est sorti du parking...Place liberée !
[4047] (Proc : 8) a donné sa carte, ATTENTE
[4547] (Proc : 8) a fini son attente
[4547] (Proc : 8) passe sur la rampe
[4547] (Proc : 8) est descendu de la rampe et est garé a sa place !
[4547] (Proc : 8) veut sortir du parking !
[4547] (Proc : 8) passe sur la rampe (pour sortir)
[4547] (Proc : 8) est descendu de la rampe (pour sortir)
[4547] (Proc : 8) est sorti du parking...Place liberée !

On voit que le proc 7 provoque un bouchon et les autres attendent qu'il soit sortit du parking.

**snipes** · 26/03/2008, 20h24

Chacun de tes threads possédent leurs propres sémaphores alors que ces derniers doivent être partagés entre les differents threads afin de servire de mécanismes de synchronisations.

effectivement j avais pas pensé a ca

je vais tester tout ca une fois devant mon pc mais ca a l air d etre exactement ce que je voulais faire

d ailleurs je connaissais pas TimeUnit

en tout cas merci pour ton aide je te tiens au courant