Utiliser un thread avec Timeout

Version imprimable

05/02/2014, 11h28
Masmeta

Utiliser un thread avec Timeout

Bonjour à tous.

Actuellement je développe une application avec un dialogue USB.Mes fonctions de lecture de données fonctionnent bien.

Cependant, j'aimerais les améliorer en réalisant la tache de lecture dans un thread indépendant qui me retourne soit un tableau d'octet suite à la réponse du matériel, soit une exception de lecture.

De plus j'aimerais définir un temps de timeout si ma fonction de lecture prend trop de temps. Le timeout génère alors une exception.

Malgré mes recherches, je ne vois pas comment implémenter ce principe de timeout sur un thread. Avez vous une idée ou une solution alternative?

Merci de votre aide
05/02/2014, 11h40
PixelJuice
Pourquoi ne pas lancer une StopWatch au début de l'execution de ton Thread ?

Après tu fais un truc du genre

Code:

int timeout = 60;
Code:

1 2 3 4 5 if (stopWatch.Elapsed.Seconds >= timeout) { // Exception }

Je n'avais pas pensé au stopwatch

L’implémentation pourrait être

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Thread th = new Thread(new ThreadStart(target));
            Stopwatch sw = new Stopwatch();
            sw.Start();
                th.Start();
                    bool timeoutflag = false;
            int mstimeout = 6000;
            do
            {
                if (sw.Elapsed.Milliseconds > mstimeout)
                    timeoutflag = true;
            } while (!timeoutflag & th.ThreadState != System.Threading.ThreadState.Stopped);
 
            if (timeoutflag)
            {
                th.Join(10);
                throw new Exception();
            }
....

Je vais tester ca ...

05/02/2014, 14h12
DonQuiche

Ouhlà, non, surtout pas, tout ça est horrible et ne donnera pas le résultat escompté.

La bonne façon de faire: il faut vérifier le temps depuis l'intérieur de ton thread "th". Autrement dit c'est la méthode désignée par "target" qu'il faut modifier. Si celle-ci utilise l'IO ou le réseau, il y a toujours des variantes de ces méthodes qui prennent en paramètre un timeout ou un CancellationToken.

La mauvaise façon de faire: si vraiment tu ne peux pas modifier "target" alors ton seul recours est d'appeler Thread.Abort. Tu crées simplement un timer et au bout de 60s tu appels Abort sur le thread à annuler, puis tu arrêtes le timer. Attention ! Abort a des chances de laisser l'état des variables partagées avec ce thread corrompues et tu pourrais te retrouver avec deadlocks et compagnie.

Ce qui ne va pas avec ta solution:
* Sur un système monothread ton timer va bouffer la moitié du temps CPU. Et sur un portable c'est un bon moyen de vider la batterie.
* Thread.Join ne fonctionne pas comme tu le penses: après dix secondes ton thread timer abandonnera "Join" mais "th" sera toujours en vie.
* Pas la peine de lancer une exception pour quitter un thread, un simple "return" suffit (ou rien du tout si tu es déjà à la fin de la méthode).
05/02/2014, 16h05
Invité

Bonjour,
Je rejoins tout à fait DonQuiche sur le principe.

Si tu as le Framework v4 minimum, je te conseille très fortement d'utiliser la classe "Task" avec les systèmes de jeton d'annulation. Encore plus idéal serait d'être en version du Framework 4.5 pour avoir accès aux mots clés "async" et "await".

Salut,

Le probleme avec l'USB c'est qu'il peut arriver que Windows bloque ou le device lui meme. Personnellement j'utilise ce genre de routine (peut-etre pas formidables mais fonctionnelles). Mais je suis pas encore familiarisé avec le 4.0 donc y'a surement mieux

Fonction d'appel :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    public bool ReadFromDevice(out byte[] Buffer, int TimeOverflow = 3000)
    {
      Buffer = new byte[0];
      Thread thTmp = new Thread(thFuncRead);
      int lTime = System.Environment.TickCount;
      thTmp.Start();
      while (thTmp.IsAlive && lTime + TimeOverflow > System.Environment.TickCount) ; // Application.DovEvents(); 
      if (!thTmp.IsAlive)
      {
        Buffer = (byte[])BufferThread.Clone();
        return true;
      }
      else
      {
        thTmp.Abort();
        return false;
      }
    }

Et ma thread de letture :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
private void thFuncRead()
    {
      Int32 bytesWritten;
      BufferThread = new byte[64];
      bool bResult = WinUSB_API.WinUsb_ReadPipe(_Device.winUSBHandle,
                             _Device.bulkInPipe,
                             BufferThread,
                             64,
                             out bytesWritten,
                             IntPtr.Zero);
      if (bResult)
        Array.Resize(ref BufferThread, bytesWritten);      
    }

Après les pipes de mes Devices sont en 64 octets. Tu adaptes en fonction des ton système.

Pour le TimOut tu t'adapte, sachant que si ton device te répond pas dans les 100ms, en général ca sent le paté ou que tu devrais envisager (si c'est toi qui le fait) d'optimiser ton firmware sur cette commande).