recherches sur les Processus

**Dino0one** · 27/06/2012, 10h45

Bonjour,

J'ai 2 questions concernant les processus et je ne vois pas du tout comment les aborder (OS :Windows)

1) Je souhaite enregistrer dans un fichier la liste des processus Windows. Comme complément : Durant l'exécution de mon programme, la liste est complétée à chaque nouveau processus. En gros enregistrer tous les processus qui ont été exécutés pendant une période sur ma machine Windows dans un fichier texte.

J'ai essayé ceci, mais ça ne répond pas vraiment à ma problématique puisque mon but est d'enregistrer tous les processus (en évitant les doublons) qui ont été exécuté durant une période prédéfinie.

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
try {
        String line;
        Process p = Runtime.getRuntime().exec
        (System.getenv("windir") +"\\system32\\"+"tasklist.exe");
 
        BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
 
        FileWriter lu = new FileWriter("monFichier.txt");
        BufferedWriter out = new BufferedWriter(lu);
        while ((line = input.readLine()) != null) {
            out.write(line); 
        }
        out.close();
        input.close();
 
    } catch (Exception err) {
        err.printStackTrace();
    }

2) Deuxième partie, Suivre l'évolution d'un processus : Pouvoir constater quand un processus défini et connu à l'avance est lancé, et lorsqu'il n'est plus.
Par exemple, dans une boucle conditionnelle, regarder à chaque tour si le processus est lancé. Pour cette question je n'ai aucune piste.

J'espère avoir été suffisamment clair dans mes explications, si ce n'est pas le cas, merci de me le signaler, afin que j'essaye de le clarifier.
D'avance merci à tout ceux qui m'apporteront une précieuse aide.

**thelvin** · 27/06/2012, 11h46

Java ne propose rien pour ça, la notion de processus externe étant assez variante avec les OS.

Il existe peut-être des bibliothèques thirdparties permettant de faire ça en Java (et pour Windows-only,) mais je n'en connais pas. Et de toute façon, Java n'est pas un bon choix pour ce besoin-là.

**wax78** · 27/06/2012, 11h53

Ce que dit Thelvin est correct.

Cependant si tu veux un truc pour windows qui marche +-, j'espère que ca te servira j'ai passé 20 minutes dessus ^^ (bon c'est bricolage mais ca marche).

Code :

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

public enum TYPE {ADDED, REMOVED};

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
/**
 * @author Warnotte Renaud
 *
 */
public class WProcess
{
	long PID;
	String name;
	long size;
	String type;	
 
	public WProcess(long pID, String name, long size, String type)
	{
		super();
		PID = pID;
		this.name = name;
		this.size = size;
		this.type = type;
	}
	public synchronized long getPID()
	{
		return PID;
	}
	public synchronized void setPID(long pID)
	{
		PID = pID;
 
	}
	public synchronized String getName()
	{
		return name;
	}
	public synchronized void setName(String name)
	{
		this.name = name;
 
	}
	public synchronized long getSize()
	{
		return size;
	}
	public synchronized void setSize(long size)
	{
		this.size = size;
 
	}
	public synchronized String getType()
	{
		return type;
	}
	public synchronized void setType(String type)
	{
		this.type = type;
 
	}
	@Override
	public String toString()
	{
		return "WProcess [PID=" + PID + ", name=" + name + "]";
	}
 
 
 
}

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
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
 
import javax.swing.event.EventListenerList;
 
/**
 * @author Warnotte Renaud
 *
 */
public class ThreadList extends Thread
{
 
	EventListenerList			ProcessNotifyListeners		= new EventListenerList();
 
	int PollingDelay = 500; // ms
 
	/**
         * @param args
         */
	public static void main(String[] args)
	{
		ThreadList tl = new ThreadList();
		tl.start();
	}
 
	public void run()
	{
		List<WProcess> lastList;
		try
		{
			lastList = ProcessLister.getProcessesList();
 
			while (true) // Pas bien :)
			{
				Thread.sleep(PollingDelay);
				List<WProcess> ret = ProcessLister.getProcessesList();
				compareList(lastList, ret);
				lastList = ret;
			}
		}
		catch (IOException | InterruptedException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	/**
         * @param lastList
         * @param newList
         */
	private void compareList(List<WProcess> lastList, List<WProcess> newList)
	{
		for (int i = 0; i < lastList.size(); i++)
		{
			WProcess wp = lastList.get(i);
			if (isPIDExistInList(newList, wp.PID) == false)
			{
				fireProcessNotify(new ProcessNotificationEvent(TYPE.REMOVED, wp));
				//System.err.println("Process " + wp + " removed");
			}
		}
		for (int i = 0; i < newList.size(); i++)
		{
			WProcess wp = newList.get(i);
			if (isPIDExistInList(lastList, wp.PID) == false)
				fireProcessNotify(new ProcessNotificationEvent(TYPE.ADDED, wp));
				//System.err.println("Process " + wp + " added");
		}
	}
 
	private boolean isPIDExistInList(List<WProcess> lastList, long PID)
	{
		for (Iterator<WProcess> iterator = lastList.iterator(); iterator.hasNext();)
		{
			WProcess wProcess = (WProcess) iterator.next();
			if (wProcess.PID == PID)
				return true;
		}
		return false;
	}
 
	public void addProcessNotifyListener(ProcessNotifiable listener)
	{
		ProcessNotifyListeners.add(ProcessNotifiable.class, listener);
	}
 
	public void removeProcessNotifyListener(ProcessNotifiable listener)
	{
		ProcessNotifyListeners.remove(ProcessNotifiable.class, listener);
	}
 
	public void fireProcessNotify(ProcessNotificationEvent xxxEvent)
	{
		Object[] listeners = ProcessNotifyListeners.getListenerList();
		// loop through each listener and pass on the event if needed
		int numListeners = listeners.length;
		for (int i = 0; i < numListeners; i += 2)
		{
			if (listeners[i] == ProcessNotifiable.class)
			{
				// pass the event to the listeners event dispatch method
				((ProcessNotifiable) listeners[i + 1]).ProcessNotification((xxxEvent));
			}
		}
	}
}

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
/**
 * @author Warnotte Renaud
 */
public class ProcessNotificationEvent
{
	TYPE		type;
	WProcess	process;
 
	public ProcessNotificationEvent(TYPE type, WProcess process)
	{
		super();
		this.type = type;
		this.process = process;
	}
 
	@Override
	public String toString()
	{
		return "ProcessNotificationEvent [type=" + type + ", process=" + process + "]";
	}
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import java.util.EventListener;
 
/**
 * 
 * @author Warnotte Renaud
 *
 */
public interface ProcessNotifiable extends EventListener
{
	void ProcessNotification(ProcessNotificationEvent wp);
}

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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
/**
 * @author user
 */
public class ProcessLister
{
 
	/**
         * @param args
         * @throws IOException
         * @throws InterruptedException
         */
	public static void main(String[] args) throws IOException, InterruptedException
	{
		List<WProcess> lastList = getProcessesList();
	}
 
	static List<WProcess> getProcessesList() throws IOException
	{
		List<WProcess> ret = new ArrayList<>();
		String line;
		Process p = Runtime.getRuntime().exec(System.getenv("windir") + "\\system32\\" + "tasklist.exe" + " /FO CSV");
 
		BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
 
		line = input.readLine();
		while ((line = input.readLine()) != null)
		{
			line = line.replaceAll("\"", "");
			String splitted[] = line.split(",");
 
			WProcess pro = createProcessFromCSVString(splitted);
 
			// Filtrage pour ne pas avoir le processus qu'on vient de lancer
			if (pro.getName().contains("tasklist.exe"))
				continue;
			if (pro.getName().contains("conhost.exe"))
				continue;
			ret.add(pro);
		}
		input.close();
		return ret;
	}
 
	/**
         * @param splitted
         * @return
         */
	private static WProcess createProcessFromCSVString(String[] splitted)
	{
		long PID = new Long("" + splitted[1]);
		String Name = splitted[0];
		String Type = splitted[2];
		WProcess pro = new WProcess(PID, Name, 0, Type);
		return pro;
	}
}

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
/**
 * @author Warnotte Renaud
 *
 */
public class mainExemple implements ProcessNotifiable
{
 
	public static void main(String args[])
	{
		new mainExemple();
	}
 
	public mainExemple()
	{
		ThreadList tl = new ThreadList();
		tl.addProcessNotifyListener(this);
		tl.start();
	}
 
	@Override
	public void ProcessNotification(ProcessNotificationEvent wp)
	{
		System.err.println("Process notification : "+wp);
 
	}
}

EDIT : Note que ca fonctionne par Polling (500ms reglable) et que donc, tu px looper des processus tres rapide (creer puis detruit en moins de 500ms) donc ce n'est pas la panacée, juste une bricole depannage

**Dino0one** · 27/06/2012, 11h56

Merci d'avoir répondu

EDIT ! JE VIENS DE VOIR LA DEUXIEME REPONSE MERCI JE REGARDE LE CODE
ET JE RE-REPONDS

Suite à la réponse de thelvin
Je ne m'attendais pas à une réponse par la négative, et pensais qu'il existait peut être des moyens de contourner le léger vide de java concernant mes problèmes

Par exemple
Pour le problème 1)
- Stocker tous les processus dans un fichier par le code que j'ai proposé.
- Extraire un à un les processus et les mettre dans un tableau
- Faire une boucle et qui fait une pause d'une minute par exemple
- Stocker à nouveau les processus dans un fichier
- Vérifier les nouveau et les ajouter au tableau

Pour le problème 2)
-Utiliser le problème 1 et vérifier qu'à chaque tour le processus recherché est bien présent dans la liste

C'est une façon de contourner les choses, qu'en pensez-vous ?
Est ce qu'il y aurait des méthodes moins "lourdes" ?

Merci à tous encore une fois

**Dino0one** · 27/06/2012, 12h05

@ wax78

WOW ! Merci d'avoir codé autant pour moi, je ne m'attendais pas à ça, c'est vraiment très sympathique de votre part.

Je regarde tout ce code de plus près suite à ma pause, et je vous recontacte en début d'après midi.

Merci pour tout!

**thelvin** · 27/06/2012, 13h28

Envoyé par Dino0one

C'est une façon de contourner les choses, qu'en pensez-vous ?
Est ce qu'il y aurait des méthodes moins "lourdes" ?

C'est exactement ce que fait le code trouvé par wax78.
Mais le polling et l'emplacement dur de tasklist, sans d'ailleurs se soucier d'autorisations dessus, c'est bancal, tout ça, bancal -_-°.

Après, c'est sûr que ça commencerait à être compliqué de faire mieux.

**wax78** · 27/06/2012, 13h57

Bah tu comprends bien que je ne me suis pas trop tracassé sur certain aspect

**wax78** · 28/06/2012, 18h31

Pour répondre a ton PM, as tu essayé le mainExemple pour voir ce qu'il faisait ?

Tu as normalement tout le nécessaire, hormis la partie ecriture de ce que tu vx savoir dans le fichier.
Tu pourrais regarder ici pour savoir comment lire/ecrire dans des fichier a l'aide de flux.

Ensuite tu chipotte dans

Code :

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

ProcessNotification(ProcessNotificationEvent wp);

afin d'enregistrer les ajouts ou suppresion de processus.

recherches sur les Processus

avec Java

Discussions similaires

Partager

Partager