Multithreading - 2 tâches

Version imprimable

25/09/2014, 17h00
Casshern

Multithreading - 2 tâches

Bonjour,
J'ai une méthode ,composée de 2 tâches T1 et T2 avec la condition suivante:Un thread peut exécuter T1 uniquement si aucun autre thread n'est entrain d'exécuter T2.
pourriez-vous m'indiquer comment coder cela?
25/09/2014, 17h13
adiGuba

Salut,

Il faut synchroniser les deux tâches avec le même lock.

a++

Il faudrait que les threads puissent continuer à exécuter simultanément la tache2
exemple :Si je fais ce qui est indiqué ci-dessous ,cela ne sera plus possible

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
package Test;
 
public class Class1 {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		Thread thread1 = new Thread(new Class2(), "thread1");
		Thread thread2 = new Thread(new Class2(), "thread2");
		Thread thread3 = new Thread(new Class2(), "thread3");
		Thread thread4 = new Thread(new Class2(), "thread4");
		Thread thread5 = new Thread(new Class2(), "thread5");
		Thread thread6 = new Thread(new Class2(), "thread6");
		Thread thread7 = new Thread(new Class2(), "thread7");
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
		thread5.start();
		thread6.start();
		thread7.start();
	}
 
}

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
package Test;
 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
 
public class Class2 implements Runnable {
 
	private static final Lock lock = new ReentrantLock();
	private static volatile Integer count = 0;
 
	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		System.out.println("=================== BEGIN "+threadName+" ===================");
 
        try {
            lock.lock();
            count++;
            if(count==2 || count ==5){
                for(int j=0;j<100;j++){
               	 System.out.println("======>"+threadName+" task1 "+j);
                }
            }
         } finally {
            lock.unlock();
         }
 
         try {
             lock.lock();
             for(int i=0;i<100;i++){
            	 System.out.println("===========>"+threadName+" task2 "+i);
             }
          } finally {
             lock.unlock();
          }
  		System.out.println("=================== END "+threadName+" ===================");
	}
}

26/09/2014, 08h35
adiGuba

Citation:

Envoyé par Casshern

Il faudrait que les threads puissent continuer à exécuter simultanément la tache2

Peut-être avec un ReadWriteLock... mais il faudrait avoir plus de détail sur tes tâches et le comportement global que tu souhaite avoir...

a++
26/09/2014, 10h37
Casshern

Salut,
les threads sont lancés à la demande par des utilisateurs U1 U2 U3 U4...
tache1:
Appel à une procédure PL\SQL P1:truncate table T1 + INSERT d'enregistrements dans T1.
On by-passe l'exécution de la tache1 si celle-ci a été exécutée il y a moins de SS secondes.
tache2:
Appel à une procédure PL\SQL P2:DELETE dans la table T2 d'enregistrements relatifs à l'utilisateur Ux + INSERT dans T2 de données relatives à l'utilisateur Ux ,récupérées à partir de données présentes dans T1
On refuse à Ux le lancement de la tache2 si la tache2 est déjà en cours d'exécution pour ce même utilisateur Ux.
26/09/2014, 11h06
Casshern

Casshern remercie adiGuba :hola:
Je regarderai de plus près ce package java.util.concurrent.locks