Discussion :

[TraPpeur]

Bonjour à tous.

J'ai une classe qui lance un thread dans le constructeur, thread qui tourne en permanence.

Ce thread doit s'arrêter lorsque'il n'existe plus de référence de l'objet qui l'a lancé. Ce qui n'est pas le cas avec le code suivant :

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
 class Toto
    {
        Thread t;
 
 
        volatile bool stop = false;
        public Toto()
        {
            t = new Thread(new ThreadStart(executingMethod));
            t.IsBackground = true;
 
            t.Start();
        }
 
        private void executingMethod()
        {
            Thread.Sleep(1000);
            while (! stop)
            {
                Console.WriteLine("Toto active");
                Thread.Sleep(1000);
            }
        }
 
        private void Stop()
        {
            Console.WriteLine("Stop called");
            stop = true;
        }
 
    }
    class Program
    {
 
        static void Main(string[] args)
        {
            Toto t = new Toto();
            Console.ReadLine();
            t = null;
 
            // J'aimerai que le thread s'arrete à ce moment la...
 
           Console.ReadLine();
 
        }
    }

J'aimerais que le thread s'arrête quand on n'utilise plus l'objet. Est-ce qu'il y a un moyen de savoir que l'objet n'a plus de référence vers lui, pour arrêter le thread automatiquement ?

Je ne sais pas si j'ai été clair.

Merci d'avance pour vos réponses !

[Themacleod1980]

salut,
pourquoi ne pas mettre Stop() en public et faire un t.Stop() ?

sinon je dirais faire une fonction qui dés-allouerait la référence (dispose() ?)et déclenchant un évènement qui exécuterait ce Stop().
(en même temps.. autant faire un t.Stop() directement ...)

hum je m'embrouille...
mais je ne pense pas que ton thread puisse savoir que ton main n'a plus de référence vers lui...

[TraPpeur]

Bonjour, merci pour ta réponse !

Le code que j'ai donnée est un exemple simplifié pour comprendre la problématique.

Je voudrais justement que si un appel vers le "stop" ou le "dispose" n'est pas fait (cas d'un oubli), le thread s'arrête bien...

[ppphil]

Et si tu oublies de faire t = null; ????
C'est pas mieux que d'oublier de faire un joli Dispose()....

[TraPpeur]

Comme je disais, ce code est la pour le test et l'exemple.

Il faut imaginer le cas ou ma classe "Toto" qui inclus le thread est embarqué dans une dll "utilitaire".

Un programme se sert de l'utilitaire, puis quand il n'en a plus besoin, la référence de l'instance toto qu'il utilisait est perdue. A ce moment la, je voudrais être sur que le thread s'arrêtera.

Je préfèrerais masquer au programme qui se servirait de "Toto" qu'il y a un thread qui tourne derrière et qu'il doit appeler la méthode "stop" avant de perdre la référence...

[nicolas.sitbon]

Tu peux utiliser le finaliser le l'objet qui à lancer le thread, mais son appel n'est déterministe. Voici un petit programme qui illustre le principe, je force simplement le garbage collector, afin que celui ci appelle bien le finaliseur.

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
using System.Net;
using System.Threading;
using System;
 
namespace ConsoleApplication1
{
    class Toto
    {
        Thread thread = new Thread(ThreadMain);
 
        static public void ThreadMain()
        {
            while (true)
            {
                Console.WriteLine("thread running");
                Thread.Sleep(1000);
            }
        }
 
        public Toto()
        {
            Console.WriteLine("start thread");
            thread.Start();
        }
 
        ~Toto()
        {
            Console.WriteLine("abort thread");
            thread.Abort();
        }
 
    }
 
    class Program
    {
        static void CreateStarterObject()
        {
            Toto t = new Toto();
            Thread.Sleep(1000);
        }
 
        static void Main(string[] args)
        {
            Console.WriteLine("Creating object");
            CreateStarterObject();
            Console.WriteLine("forcing garbage collection");
            GC.Collect();      
            Console.ReadLine();
        }
    }
}

Cordialement.

[TraPpeur]

C'est parfait, merci beaucoup !

[nicolas.sitbon]

You're welcome, pense au tag "Résolu".

[TraPpeur]

En fait non, c'est "presque parfait"...

J'abuse encore un peu...

Si on enleve le "static" de la méthode qui s'execute dans le thread ("static public void ThreadMain()"), cela ne marche plus....

Pourquoi ?

Merci !

[nicolas.sitbon]

Si on enleve le "static" de la méthode qui s'execute dans le thread ("static public void ThreadMain()"), cela ne marche plus....

Pourquoi ?

Quand tu enlèves le mot clé "static" tu en fais une méthode d'instance donc liée à un objet, autrement dit, le "delegate" passé en premier argument du constructeur de la classe Thread contient une référence verse l'objet Toto (qui contient la méthode d'instance).

[TraPpeur]

ok, donc pas d'autres solutions en somme...

[TraPpeur]

Il y a peut être une piste avec les "Weak Reference" mais je n'ai pas réussi a trouver le truc...

[ketan]

Bonjour,

Je ne pense pas que tu puisse utiliser les WeakReference pour passer ton delegate (à moins de partir dans un truc un peu copieux et complexe).
Par contre, tu pourrais garder ta méthode statique et lui passer comme argument une WeakReference vers l'objet qui a lancé le thread.

[nicolas.sitbon]

D'un autre coté, je ne vois pas où est le problème avec la méthode statique...

[TraPpeur]

Bon je pense que j'ai réussi à faire ce que je voulais en me basant sur cet exemple :

http://stackoverflow.com/questions/3...l-threads-in-c

Voila ce que ca donne :

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
class Program
    {
 
        class Toto
        {
            private delegate void action();
 
            public Toto()
            {
                MethodInfo mi1 = typeof(Toto).GetMethod("Action",
                BindingFlags.NonPublic | BindingFlags.Instance);
 
 
                Delegate act = Delegate.CreateDelegate((typeof(action)), this, mi1);
 
                AutoStopThread t = new AutoStopThread(1000, act);
 
            }
 
            private void Action()
            {
                Console.WriteLine("One Action is done in thread : " + Thread.CurrentThread.ManagedThreadId);
            }
        }
 
 
        static void CreateStarterObject()
        {
            Toto t = new Toto();
            Thread.Sleep(5000);
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Creating object in thread : " + Thread.CurrentThread.ManagedThreadId);
            CreateStarterObject();
            Console.WriteLine("forcing garbage collection in thread : " + Thread.CurrentThread.ManagedThreadId);
            GC.Collect();
            Console.ReadLine();
        }
    }
 
 
    class WeakReferenceThread
    {
        Thread t;
 
        WeakReference fishRef;
        WeakReference traitement;
 
        public ManualResetEvent terminate = new ManualResetEvent(false);
 
        private volatile bool stop ;
 
 
        public WeakReferenceThread(AutoStopThread fish, Delegate d)
        {
            this.fishRef = new WeakReference(fish);
            this.traitement =  new WeakReference(d);
        }
 
        public void Start()
        {
            t = new Thread(new ThreadStart(BackgroundWork));
            t.IsBackground = true;
            stop = false;
            t.Start();       
        }
 
        public void Stop()
        {
            stop = true;
        }
 
        public void BackgroundWork()
        {
            //bool done = false;
            while (! stop)
            {
                CallWork(); // Test
                //stop = terminate.WaitOne(1000, false);               
            }
        }
 
        // this is pulled out into a helper method to ensure 
        // the Fish object is referenced for the minimal amount of time
        private void CallWork()
        {
            //bool done;
 
            AutoStopThread fish = Fish;
            if (fish != null)
            {
                ((Delegate)this.traitement.Target).DynamicInvoke();
                //fish.Swim();
                stop = false;
            }
            else
            {
                stop = true;
            }
            ///return done;
        }
 
        public AutoStopThread Fish
        {
            get { return fishRef.Target as AutoStopThread; }
        }
    }
 
 
 
    class AutoStopThread : IDisposable
    {
        internal class AutoStopThreadWork
        {
            Thread t;
            WeakReference fishRef;
            WeakReference actionDelegate;
            public ManualResetEvent terminate = new ManualResetEvent(false);
            int actionFrequenceMlSec;
 
            public AutoStopThreadWork(AutoStopThread fish, int actionFrequenceMlSec, Delegate action)
            {
                this.fishRef = new WeakReference(fish);
                this.actionDelegate = new WeakReference(action);
                t = new Thread(new ThreadStart(BackgroundWork));
                this.actionFrequenceMlSec = actionFrequenceMlSec;
                t.IsBackground = true;
                t.Start();
            }
 
            public void BackgroundWork()
            {
                bool done = false;
                while (!done)
                {
                    done = Swim();
                    if (!done)
                    {
                        done = terminate.WaitOne(this.actionFrequenceMlSec, false);
                    }
                }
            }
 
            // this is pulled out into a helper method to ensure 
            // the Fish object is referenced for the minimal amount of time
            private bool Swim()
            {
                bool done;
 
                AutoStopThread fish = Fish;
                if (fish != null)
                {
                    //fish.Swim();
                    ((Delegate)(this.actionDelegate.Target)).DynamicInvoke();
                    done = false;
                }
                else
                {
                    done = true;
                }
                return done;
            }
 
            public AutoStopThread Fish
            {
                get { return fishRef.Target as AutoStopThread; }
            }
        }
 
        AutoStopThreadWork autoStopThread;
 
        //private delegate void action();
 
        public AutoStopThread(int actionFrequenceMlSec, Delegate action)
        {
            //MethodInfo mi1 = typeof(Program).GetMethod("Swim",
            //BindingFlags.Public | BindingFlags.Static);
 
 
            //Delegate act = Delegate.CreateDelegate((typeof(action)),this,  mi1);
            autoStopThread = new AutoStopThreadWork(this, actionFrequenceMlSec, action);
        }
 
        //public void Swim()
        //{
        //    Console.WriteLine("The Action is done");
        //}
 
        volatile bool disposed = false;
 
        public void Dispose()
        {
            if (!disposed)
            {
                autoStopThread.terminate.Set();
                disposed = true;
                GC.SuppressFinalize(this);
            }
        }
 
        ~AutoStopThread()
        {
            if (!disposed)
            {
                Dispose();
            }
        }
    }

Merci pour l'aide!