.NET में वर्तमान में सक्रिय प्रबंधित थ्रेड की सूची प्राप्त करना?

Question

फ़ंक्शन के प्रकार "समर्थन के लिए लॉग जानकारी" के लिए मैं सक्रिय थ्रेड जानकारी को गणना और डंप करना चाहता हूं।

मैं इस तथ्य से अच्छी तरह से अवगत हूं कि दौड़ की स्थिति इस जानकारी को अर्द्ध-गलत बना सकती है, लेकिन मैं सर्वोत्तम संभव परिणाम प्राप्त करने का प्रयास करना चाहता हूं, भले ही यह 100% सटीक न हो।

मैंने प्रक्रिया को देखा। थ्रेड, लेकिन यह प्रोसेस थ्रेड ऑब्जेक्ट्स लौटाता है, मैं थ्रेड ऑब्जेक्ट्स का संग्रह करना चाहता हूं, ताकि मैं उनका नाम लॉग कर सकूं, और वे पृष्ठभूमि धागे हैं या नहीं।

क्या ऐसा कोई संग्रह उपलब्ध है, भले ही यह सक्रिय धागे का स्नैपशॉट है जब मैं इसे कॉल करता हूं?

यानी।

Thread[] activeThreads = ?? 

ध्यान दें, स्पष्ट होना, मैं नहीं Process.Threads के बारे में पूछ रहा हूँ, इस संग्रह मुझे बहुत देता है, लेकिन मैं क्या चाहते हैं के सभी नहीं। मैं जानना चाहता हूं कि हमारे आवेदन में थ्रेड का नाम कितना समय उपयोग कर रहा है (जिसका मतलब है कि मुझे बाद में दो प्रकार की वस्तुओं को जोड़ने पर ध्यान देना होगा, लेकिन सीपीयू समय से शुरू होने के लिए नाम अधिक महत्वपूर्ण हैं।)

Answer 1

यदि आप अपने आवेदन के Thread अन्य रैपर वर्ग के साथ रचनाओं को प्रतिस्थापित करने के इच्छुक हैं, तो कहा गया है कि रैपर क्लास सक्रिय और निष्क्रिय Thread एस आपके लिए ट्रैक कर सकता है। यहाँ इस तरह के एक आवरण का एक न्यूनतम व्यावहारिक खोल दिया गया है:

namespace ThreadTracker 
{ 
    using System.Collections.Generic; 
    using System.Collections.ObjectModel; 
    using System.Threading; 

    public class TrackedThread 
    { 
     private static readonly IList<Thread> threadList = new List<Thread>(); 

     private readonly Thread thread; 

     private readonly ParameterizedThreadStart start1; 

     private readonly ThreadStart start2; 

     public TrackedThread(ParameterizedThreadStart start) 
     { 
      this.start1 = start; 
      this.thread = new Thread(this.StartThreadParameterized); 
      lock (threadList) 
      { 
       threadList.Add(this.thread); 
      } 
     } 

     public TrackedThread(ThreadStart start) 
     { 
      this.start2 = start; 
      this.thread = new Thread(this.StartThread); 
      lock (threadList) 
      { 
       threadList.Add(this.thread); 
      } 
     } 

     public TrackedThread(ParameterizedThreadStart start, int maxStackSize) 
     { 
      this.start1 = start; 
      this.thread = new Thread(this.StartThreadParameterized, maxStackSize); 
      lock (threadList) 
      { 
       threadList.Add(this.thread); 
      } 
     } 

     public TrackedThread(ThreadStart start, int maxStackSize) 
     { 
      this.start2 = start; 
      this.thread = new Thread(this.StartThread, maxStackSize); 
      lock (threadList) 
      { 
       threadList.Add(this.thread); 
      } 
     } 

     public static int Count 
     { 
      get 
      { 
       lock (threadList) 
       { 
        return threadList.Count; 
       } 
      } 
     } 

     public static IEnumerable<Thread> ThreadList 
     { 
      get 
      { 
       lock (threadList) 
       { 
        return new ReadOnlyCollection<Thread>(threadList); 
       } 
      } 
     } 

     // either: (a) expose the thread object itself via a property or, 
     // (b) expose the other Thread public methods you need to replicate. 
     // This example uses (a). 
     public Thread Thread 
     { 
      get 
      { 
       return this.thread; 
      } 
     } 

     private void StartThreadParameterized(object obj) 
     { 
      try 
      { 
       this.start1(obj); 
      } 
      finally 
      { 
       lock (threadList) 
       { 
        threadList.Remove(this.thread); 
       } 
      } 
     } 

     private void StartThread() 
     { 
      try 
      { 
       this.start2(); 
      } 
      finally 
      { 
       lock (threadList) 
       { 
        threadList.Remove(this.thread); 
       } 
      } 
     } 
    } 
} 

और इसके बारे में एक त्वरित परीक्षण ड्राइवर (ध्यान दें मैं धागे की सूची पर पुनरावृति नहीं है, केवल सूची में संख्या प्राप्त):

namespace ThreadTracker 
{ 
    using System; 
    using System.Threading; 

    internal static class Program 
    { 
     private static void Main() 
     { 
      var thread1 = new TrackedThread(DoNothingForFiveSeconds); 
      var thread2 = new TrackedThread(DoNothingForTenSeconds); 
      var thread3 = new TrackedThread(DoNothingForSomeTime); 

      thread1.Thread.Start(); 
      thread2.Thread.Start(); 
      thread3.Thread.Start(15); 
      while (TrackedThread.Count > 0) 
      { 
       Console.WriteLine(TrackedThread.Count); 
      } 

      Console.ReadLine(); 
     } 

     private static void DoNothingForFiveSeconds() 
     { 
      Thread.Sleep(5000); 
     } 

     private static void DoNothingForTenSeconds() 
     { 
      Thread.Sleep(10000); 
     } 

     private static void DoNothingForSomeTime(object seconds) 
     { 
      Thread.Sleep(1000 * (int)seconds); 
     } 
    } 
} 

सुनिश्चित नहीं है कि आप इस तरह के मार्ग पर जा सकते हैं, लेकिन यदि आप विकास के शुरुआती चरण में शामिल करने में सक्षम हैं तो यह लक्ष्य पूरा करेगा।

Answer 2

क्या आप अपने आवेदन में प्रत्येक थ्रेड बनाते समय थ्रेड जानकारी को लुकअप में संग्रहीत करना संभव है?

प्रत्येक धागा शुरू होने के बाद, आप AppDomain.GetCurrentThreadId() का उपयोग कर अपना आईडी प्राप्त कर सकते हैं। बाद में, आप इसका उपयोग Process.Threads से लौटाए गए डेटा के संदर्भ में पार करने के लिए कर सकते हैं।