Discussion :

[man84]

salut,

je voudrais gérer et contrôler mes variables globales d'une classe mère dans une autre classe interne qui utilise des threads.

autrement dit comment conserver les valeurs de chaque variable globale appelé dans une classe thready.

et merci

[joel.drigo]

Salut,

Il n'y a pas de notion de variables globales en Java. On peut déclarer des variables comme public static, ce qui permet à des variables d'être d'une part accessibles par toutes autres classes (le public) et à ne pas être attachées à une instance particulière. Si la variable doit être modifiée et lue par différents threads, on la déclarera volatile en plus.

Par exemple, si on a une variable déclarée comme ça :

Code :

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

1
2
3
4
5
public class UneClasse {
 
    public static volatile String variable = "truc";
 
}

On pourra y accèder comme ça :

Code :

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

1
2
3
4
5
6
7
public class UneAutreClasse {
 
    public void uneMethode() {
         System.out.println( UneClasse.variable );
    }
 
}

Si la classe est interne elle pourra toujours accèder aux variables membres, même si elles ne sont ni static ni public.

Exemple avec classes anonymes :

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
public class DemoVar {
 
	private volatile int variable;
 
	public DemoVar() {
		new Thread() {
 
			@Override
			public void run() {
				while(true) {
					System.out.println(variable);
					try {
						sleep(500);
					} catch (InterruptedException e) {
						break;
					}
				}
			}
 
		}.start();
 
		new Thread() {
 
			@Override
			public void run() {
				while(true) {
					variable++;
					System.out.println("variable modifiée");
					try {
						sleep(1500);
					} catch (InterruptedException e) {
						break;
					}
				}
			}
 
		}.start();
	}
 
	public static void main(String[] args) {
 
		new DemoVar();
 
	}
 
}

Exemple avec classes internes :

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
public class DemoVar {
 
	private volatile int variable;
 
	public DemoVar() {
		new Thread(new ReadRunnable()).start();		
		new Thread(new WriteRunnable()).start();
	}
 
	private class ReadRunnable implements Runnable {
		@Override
		public void run() {
			while(true) {
				System.out.println(variable);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					break;
				}
			}
		}
 
	}
 
	private class WriteRunnable implements Runnable {
		@Override
		public void run() {
			while(true) {
				variable++;
				System.out.println("variable modifiée");
				try {
					Thread.sleep(1500);
				} catch (InterruptedException e) {
					break;
				}
			}
		}
 
	}
 
 
	public static void main(String[] args) {
 
		new DemoVar();
 
	}
 
}

[eulbobo]

Sinon, tu peux aussi aller faire un tour dans le package java.util.concurrent pour regarder les objets qui s'appellent AtomicBoolean, AtomicInteger, AtomicLong... bref, plein d'objets pour manipuler toutes sortes d'objets dans un contextes concurrentiel en limitant les risques de modification concurrentes et de lock.

[man84]

Salut,

Je suis tout a fait d'accord avec ces solutions que vous m'avez proposé , mais mon intérêt de déclarer des variables qu'on peut les utiliser dans une classe thready c'est en fait comme la notion des variables locales dans une fonction càd je veux lancer plusieurs thread qui ont les mêmes variables mais leurs valeurs sont différentes selon notre traitement dans autre classe.

[tchize_]

"thready" n'est pas une notion de programmation, donc dur de savoir précisément ce que tu veux.
Les champs des classes étant spécifiques à chaque instance, il suffit de filer des instances différentes de tes classes à chaque thread et tu n'aura pas de soucis entre les thread.
Si ce que tu cherche à faire c'est à stocker une variable "globale" mais dont l'état dépend du thread qui la lit, regarde du coté de la classe ThreadLocal.

[man84]

"thready" n'est pas une notion de programmation, donc dur de savoir précisément ce que tu veux.
Les champs des classes étant spécifiques à chaque instance, il suffit de filer des instances différentes de tes classes à chaque thread et tu n'aura pas de soucis entre les thread.
Si ce que tu cherche à faire c'est à stocker une variable "globale" mais dont l'état dépend du thread qui la lit, regarde du coté de la classe ThreadLocal.

Exactement ce que vous avez dit, on veut utiliser les variables globales dont leur état dépend du thread lancer et en cours d'éxecution.
voila un exemple expliquant mon but :

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
public class projet
{
public int variable_global = 0;
 
projet() {
 
            Applica ap = new Applica();
	       ap = new Thread();
	       ap.start();
 
 
	       ap = new Thread( new String("salut") );
               ap.start();
 
 
	       ap = new Thread();
	       ap.start();
 
 
           }
 
 
Public void main()
{
  new projet();
}
 
}

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
public class Applica extends Thread
{ 
        public String msg;
 
 
	public Applica() 
        {
		// TODO Auto-generated constructor stub
	        this.variable_global= 3;
 
	}	
 
       public Applica(String msg) 
        {
	        this.variable_global= 10;
                this.msg=msg;
 
	}	
 
 
	public void run()
	{
	      while(true) {
              System.out.println(" afficher le message "+msg);
              System.out.println(" la valeur de variable"+variable_global);  
		}
	}	//fin run()
 
}

mon projet lance plusieurs threads en paralelle, mais je veux la valeur de variable de chaque thread reste au meme thread.une autre solution c'est de declarer le variable variable_global au classse thread et l'exploiter en classe projet mais il me donne erreur car ce variable est seulement propre au classe thread.

[tchize_]

Même si ThreadLocal peut t'apporter une solution, je ne te le recommande pas. Commence par regarder à filer une instance de ton set de variable à chaque Thread. Si "Projet" a besoin de variables, mais qu'elles doivent être différenciée par thread, ça veux surement dire que ce dont tu as besoin, c'est d'une instance de Projet par thread et non pas d'une instance globale. On utilise une instance de type ThreadLocal quand on n'a pas le choix, par exemple quand on n'a aucun controle sur la création de Threads comme dans une serveur d'application, et que l'on n'a pas accès aux structure chargée habituellement de stocker les informations spéciques prévues par le conteneur. Avec les systèmes d'injection actuels, c'est devenu assez rare.

[joel.drigo]

Ce n'est pas du tout ce dont parlais @Tchize_ : il parlait d'une variable qui a une valeur différente pour chaque thread qui la manipule (on utilise une variable de type ThreadLocal pour gérer ça).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class UneClasse {
 
      private void ThreadLocal<Integer> var = new ThreadLocal<>();
 
      public void set(int i) {
           var.set(i);
      }
 
      public int get() {
            return var.get();
      }
 
}

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
public class Demo {
 
    public static void main(String[] args) {
 
              UneClasse uneClasse = new UneClasse();
 
              new Thread() {
 
                   public void run() {
 
                           uneClasse.set( 42 );
 
 
                           while( true ) {
 
                                  System.out.println("Variable thread 1 : " + uneClasse.get() );
 
                           }
 
                   }
              }.start();
 
 
             new Thread() {
 
                   public void run() {
 
                           uneClasse.set( 139 );
 
 
                           while( true ) {
 
                                  System.out.println("Variable thread 2 : " + uneClasse.get() );
 
                           }
 
                   }
              }.start();
    }
 
 
}

Ce programme affiche en continu des lignes comme ça :

Variable thread 1 : 42
Variable thread 2 : 139

C'est la même instance de UneClasse, la même variable, mais chaque thread à sa propre valeur.

Dans ton cas, tu as une variable qui est membre de la classe Projet et tu veux y accèder dans une autre classe, Applica. La variable étant membre de Projet elle n'est accessible depuis une instance de Applica que par l'intermédiaire d'une instance de classe Projet.

Le code que tu montres semble par contre contradictoire à ce que tu expliques, qui n'est pas très clair d'un autre côté. Dans le code que tu montres, il semble que tu aies besoin simplement d'une variable statique (une seule valeur en commun à toutes les classes) :

Code :

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

1
2
3
4
5
6
public class UneClasse {
 
            public static volatile int variable;
 
 
}

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
public class Demo {
 
    public static void main(String[] args) {
 
 
 
              new Thread() {
 
                   public void run() {
                           UneClasse uneClasse = new UneClasse();
 
                           while( true ) {
                                 uneClasse.variable ++; 
 
 
 
                                  System.out.println("Variable thread 1 : " + uneClasse.variable );
 
                           }
 
                   }
              }.start();
 
 
             new Thread() {
 
                   public void run() {
                           UneClasse uneClasse = new UneClasse();
 
 
                           while( true ) {
 
* * * * * * * * * * * *       * * uneClasse.variable ++;*
 
                                  System.out.println("Variable thread 2 : " + uneClasse.variable );
 
                           }
 
                   }
              }.start();
    }
 
 
}

Ici chaque thread a sa propre instance de UneClasse, mais la variable est static, donc unique (n'est pas attachée à une instance en particulier), en quelque sorte partagée entre toutes les instances. Donc les 2 threads vont continuellement incrémenter la même valeur et le programme va afficher des lignes comme ça :

Variable thread 1 : 1
Variable thread 2 : 2
Variable thread 1 : 3
Variable thread 2 : 4
Variable thread 1 : 6
Variable thread 2 : 6
Variable thread 1 : 7
Variable thread 1 : 9
Variable thread 2 : 9

etc...