Discussion :

[Palsajicoco]

salut,

Je fait une boucle pour exécuter des threads, j'appelle dans ma boucle les threads par leurs index, et du coup dans l’exécution, je retrouve que parfois un thread se répète

Voici le code:

Code :

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

1
2
3
4
5
for (int i = 0; i < workersToDoCopy.size(); i++) {
					Integer currentWorker = workerIterator.next();
					Processor processor = new Processor(currentWorker);
					new Thread(processor).start();
				}

et la console:

Workers to process during this iteration: [4, 5, 6, 7, 8, 9, 0, 2, 1, 11, 10, 3]
13:57:40 Complex processing started for 8.
13:57:40 Processing completed by 6.
13:57:40 Processing completed by 9.
13:57:40 Complex processing started for 4.
13:57:41 Processing completed by 7.
13:57:41 Complex processing started for 5.
13:57:41 Processing completed by 8.
13:57:41 Complex processing started for 4.
13:57:44 Processing completed by 4.
13:57:44 Complex processing started for 3.
13:57:44 Processing completed by 3.
13:57:44 Complex processing started for 5.
13:57:44 Complex processing started for 6.
13:57:44 Processing completed by 4.
TIMEOUT
Workers Done: 7 -> [6, 9, 7, 8, 4, 3, 4]
Workers Left: 6 -> [5, 0, 2, 1, 11, 10]

On voit bien que le thread 4 se répète 2 fois !!

[bulbo]

Salut,

Avec le code que l'on voit difficile de dire quoi que ce soit.

Juste une chose, je ne suis pas fan du tout de l'approche boucle for sur une taille et accès par le biais d'un iterator à l'intérieur, c'est soit l'un soit l'autre mais pas de mix pitié.

Si on utilise la taille d'une liste on accède aux éléments dans la boucle par un get en utilisant l'index de la boucle for

Si on utilise un iterator alors on utilise une boucle while(iterator.hasNext()) et on accède aux éléments grâce à next().

Bulbo

[Palsajicoco]

Merci pour la réponse, voici la continuité du code si ça peut aider:

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
 
public class SemaphoreTest {
	// static Date now = new Date();
	// private static final Log log = LogFactory.getLog(SemaphoreTest.class);
	public static int numEquipment = 12;
	static List<Integer> workers = new LinkedList<Integer>();
	static List<Integer> processedWorkers = new LinkedList<Integer>();
	static List<Integer> workersToDo = new LinkedList<Integer>();
 
	public static void initWorkers() {
		for (int w = 0; w < numEquipment; w++) {
			workers.add(w);
		}
 
		workersToDo.addAll(workers);
	}
 
	public static void log(Object o) {
		System.out.println(o.toString());
	}
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Timer timer;
		timer = new Timer();
		timer.schedule(new RemindTask(), 0, 7 * 1000);
	}
 
	static class RemindTask extends TimerTask {
		// init endDate (schedule)
		int j = 0;
		public static Date endDate;
		public static Date startDate;
 
		public RemindTask() {
			super();
 
			DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
 
			{
				try {
					startDate = dateFormat.parse("05/26/2011 13:13:12");
					endDate = dateFormat.parse("07/29/2011 12:55:12");
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			initWorkers();
		}
 
		@Override
		public void run() {
			if (endDate.after(new Date())) {
				log("Iteration " + j);
				log("Workers to process during this iteration: " + workersToDo);
 
				processedWorkers.clear();
 
				List<Integer> workersToDoCopy = new LinkedList<Integer>(
						workersToDo);
				Iterator<Integer> workerIterator = workersToDoCopy.iterator();
 
				for (int i = 0; i < workersToDoCopy.size(); i++) {
					Integer currentWorker = workerIterator.next();
					Processor processor = new Processor(currentWorker);
					new Thread(processor).start();
					// workersToDo.remove(currentWorker);
					// processedWorkers.add(currentWorker);
				}
				try {
					synchronized (this) {
						wait(5000);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				log("TIMEOUT FOR THE CURRENT ITERATION");
				for (int j = 0; j < ComplexProcess.threads.size(); j++) {
					workersToDo.remove(ComplexProcess.threads.get(j));
					processedWorkers.add(ComplexProcess.threads.get(j));
				}
 
				j++;
			} else {
				System.exit(0);
			}
 
			log("Workers Done: " + processedWorkers.size() + " -> "
					+ processedWorkers);
			log("Workers Left: " + workersToDo.size() + " -> " + workersToDo);
			workersToDo.addAll(processedWorkers);
			ComplexProcess.threads.clear();
 
			/*
			 * for (Integer w : workers) { log.debug(w + " processed " +
			 * w.getProcessCount()); }
			 */
		}
	}
}

[bulbo]

Et la classe Processor ? On peut la voir, parce qu'encore une fois, à part ta boucle un peu bancale, et deux ou trois autres choses, je ne vois pas ce qui ferait que tu ai 2 fois le même process de lancé.

Ensuite faudra m'expliquer toutes ces copies de liste d'objets immutable .. à priori ce n'est pas vraiment utile.

Bulbo

[Palsajicoco]

Ok, mon processus est super compliqué, je devrai lancer des threads avec un nombre defini a chaque fois géré par semaphore ici:

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
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Semaphore;
 
public class ComplexProcess {
	private static final int MAX_THREADS = 3; // maxConcurrent (schedule)
	private static final Random rand = new Random();
	private static Semaphore accessControl = new Semaphore(MAX_THREADS);
	private Integer name = null;
	static List<Integer> threads = new LinkedList<Integer>();
 
	public ComplexProcess(Integer name) {
		this.name = name;
	}
 
	public void doSomething() {
		// Check if permit is available
		if (this.acquireAccess()) {
			printMessage("Complex processing started for " + this.name + ".");
		}
 
		try {
			Thread.sleep(rand.nextInt(5000));
 
			// gatherXXXData
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
 
		this.releaseAccess();
		printMessage("Processing completed by " + this.name + ".");
		threads.add(this.name);
	}
 
	private static void printMessage(String message) {
		DateFormat df = new SimpleDateFormat("HH:mm:ss");
		System.out.println(df.format(new java.util.Date()) + " " + message);
	}
 
	private boolean acquireAccess() {
		try {
			accessControl.acquire();
		} catch (InterruptedException e) {
			e.printStackTrace();
			throw new RuntimeException("Unable to acquire Semaphore.", e);
		}
 
		return true;
	}
 
	public boolean releaseAccess() {
		accessControl.release();
 
		return true;
	}
}

et puis je run le thread:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Processor implements Runnable {
 
	private Integer threadName = null;
 
	public Processor(Integer name) {
		this.threadName = name;
	}
 
	public void run() {
		ComplexProcess busProcess = new ComplexProcess(this.threadName);
		busProcess.doSomething();
	}
 
}

après j’implémente les threads. en gros, je lance tous les threads, puis avec les listes je filtres ceux qui sont déjà fait, et ceux qui ne le sont pas, je devrai commencer avec eux la prochaine boucle du RemindTask. pas sur que tous les threads seront procédés dans un seul lap de temps du RemindTask.

[bulbo]

Franchement je ne vois pas ce qui pourrais déclencher un tel comportement.

Déjà il faudrait que tu fasses attention à ton usage des méthodes statiques. Ca peut te jouer des tours, surtout que je pense que tu les utilises à mauvais escient, des méthodes standards seraient tout à fait adaptée dans la plupart des cas ou tu as des statics.

Bulbo

[bulbo]

Autre point qui pourrait te poser soucis, j'ai vu que tu lançais des runtime exceptions .. mais que tu ne les catchais pas .. comme tu travailles avec des threads, ces exceptions sont simplement perdues et ne vont pas interrompre ton process principal.. mais toi tu ne sais pas ce qui a été lancé ou pas comme exception.

Juste à des fins de debug, met un try catch (Exception) avec un printStackTrace autour du code de ton run dans Processor, il se pourrait qu'on voit passer plus de choses.

Bulbo

[Palsajicoco]

Merci pour la reponse,

C'est bizarre et c'est difficile à valider vu que ça n'arrive pas toujours