Semaphore ! ne s'arrete jamais

Version imprimable

salut les amis :yaisse2:
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 :aie:

voici le code

Code:

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:

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();
 
	}
 
}

26/03/2008, 08h35
divxdede

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.
26/03/2008, 17h00
snipes
Citation:

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

j'ai fait un truc du style :
Code:

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...
26/03/2008, 17h19
divxdede

je ne comprends pas en quoi ce "sleep" t'indique que les méthodes acquire n'ont pas provoquées d'attentes ?
26/03/2008, 18h05
snipes

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 :roll:
26/03/2008, 18h58
divxdede

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.

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

Code:

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();
 
    }
 
}

Voici la sortie que cela donne

Code:

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.

26/03/2008, 19h24
snipes

Citation:

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 :lol:

d ailleurs je connaissais pas TimeUnit :roll:

en tout cas merci pour ton aide je te tiens au courant
27/03/2008, 15h42
snipes

me revoila
eh ben rien a dire ca marche nickel :king:
merci pour ton aide !