Udostępnij za pośrednictwem


ThreadPool.GetMaxThreads(Int32, Int32) Metoda

Definicja

Pobiera liczbę żądań do puli wątków, które mogą być aktywne współbieżnie. Wszystkie żądania powyżej tej liczby pozostają w kolejce, dopóki wątki puli wątków nie staną się dostępne.

public:
 static void GetMaxThreads([Runtime::InteropServices::Out] int % workerThreads, [Runtime::InteropServices::Out] int % completionPortThreads);
public static void GetMaxThreads (out int workerThreads, out int completionPortThreads);
static member GetMaxThreads : int * int -> unit
Public Shared Sub GetMaxThreads (ByRef workerThreads As Integer, ByRef completionPortThreads As Integer)

Parametry

workerThreads
Int32

Maksymalna liczba wątków roboczych w puli wątków.

completionPortThreads
Int32

Maksymalna liczba asynchronicznych wątków we/wy w puli wątków.

Przykłady

Poniższy przykład kodu pokazuje, jak pobrać liczbę maksymalną i dostępną liczbę wątków w puli wątków. Element roboczy jest w kolejce używany FileStream do asynchronicznego zapisu w dwóch plikach. Metody wywołania zwrotnego są nakładające się na siebie. Wątek roboczy obsługuje element roboczy i w zależności od szybkości i liczby procesorów na komputerze jeden lub dwa wątki portów uzupełniania obsługują operacje zapisu.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

ref class ThreadPoolTest
{
private:

   // Maintains state information to be passed to EndWriteCallback.
   // This information allows the callback to end the asynchronous
   // write operation and signal when it is finished.
   ref class State
   {
   public:
      FileStream^ fStream;
      AutoResetEvent^ autoEvent;
      State( FileStream^ fStream, AutoResetEvent^ autoEvent )
      {
         this->fStream = fStream;
         this->autoEvent = autoEvent;
      }

   };


public:
   ThreadPoolTest(){}

   static void EndWriteCallback( IAsyncResult^ asyncResult )
   {
      Console::WriteLine( "Starting EndWriteCallback." );
      State^ stateInfo = dynamic_cast<State^>(asyncResult->AsyncState);
      int workerThreads;
      int portThreads;
      try
      {
         ThreadPool::GetAvailableThreads( workerThreads, portThreads );
         Console::WriteLine( "\nAvailable worker threads: \t{0}"
         "\nAvailable completion port threads: {1}\n", workerThreads.ToString(), portThreads.ToString() );
         stateInfo->fStream->EndWrite( asyncResult );
         
         // Sleep so the other thread has a chance to run
         // before the current thread ends.
         Thread::Sleep( 1500 );
      }
      catch ( Exception^ e ) 
      {
      }
      finally
      {
         
         // Signal that the current thread is finished.
         stateInfo->autoEvent->Set();
         Console::WriteLine( "Ending EndWriteCallback." );
      }

   }

   static void WorkItemMethod( Object^ mainEvent )
   {
      Console::WriteLine( "\nStarting WorkItem.\n" );
      AutoResetEvent^ autoEvent = gcnew AutoResetEvent( false );
      
      // Create some data.
      const int ArraySize = 10000;
      const int BufferSize = 1000;
      array<Byte>^byteArray = gcnew array<Byte>(ArraySize);
      (gcnew Random)->NextBytes( byteArray );
      
      // Create two files and two State objects. 
      FileStream^ fileWriter1 = gcnew FileStream(  "C:\\Test1@##.dat",FileMode::Create,FileAccess::ReadWrite,FileShare::ReadWrite,BufferSize,true );
      FileStream^ fileWriter2 = gcnew FileStream(  "C:\\Test2@##.dat",FileMode::Create,FileAccess::ReadWrite,FileShare::ReadWrite,BufferSize,true );
      State^ stateInfo1 = gcnew State( fileWriter1,autoEvent );
      State^ stateInfo2 = gcnew State( fileWriter2,autoEvent );
      
      // Asynchronously write to the files.
      fileWriter1->BeginWrite( byteArray, 0, byteArray->Length, gcnew AsyncCallback( &ThreadPoolTest::EndWriteCallback ), stateInfo1 );
      fileWriter2->BeginWrite( byteArray, 0, byteArray->Length, gcnew AsyncCallback( &ThreadPoolTest::EndWriteCallback ), stateInfo2 );
      
      // Wait for each callback to finish.
      autoEvent->WaitOne();
      autoEvent->WaitOne();
      fileWriter1->Close();
      fileWriter2->Close();
      Console::WriteLine( "\nEnding WorkItem.\n" );
      
      // Signal Main that the work item is finished.
      dynamic_cast<AutoResetEvent^>(mainEvent)->Set();
   }

};

int main()
{
   AutoResetEvent^ mainEvent = gcnew AutoResetEvent( false );
   int workerThreads;
   int portThreads;
   ThreadPool::GetMaxThreads( workerThreads, portThreads );
   Console::WriteLine( "\nMaximum worker threads: \t{0}"
   "\nMaximum completion port threads: {1}", workerThreads.ToString(), portThreads.ToString() );
   ThreadPool::GetAvailableThreads( workerThreads, portThreads );
   Console::WriteLine( "\nAvailable worker threads: \t{0}"
   "\nAvailable completion port threads: {1}\n", workerThreads.ToString(), portThreads.ToString() );
   ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &ThreadPoolTest::WorkItemMethod ), mainEvent );
   
   // Since ThreadPool threads are background threads, 
   // wait for the work item to signal before ending main().
   mainEvent->WaitOne( 5000, false );
}
using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

class Test
{
    static void Main()
    {
        AutoResetEvent mainEvent = new AutoResetEvent(false);
        int workerThreads;
        int portThreads;

        ThreadPool.GetMaxThreads(out workerThreads, out portThreads);
        Console.WriteLine("\nMaximum worker threads: \t{0}" +
            "\nMaximum completion port threads: {1}",
            workerThreads, portThreads);

        ThreadPool.GetAvailableThreads(out workerThreads, 
            out portThreads);
        Console.WriteLine("\nAvailable worker threads: \t{0}" +
            "\nAvailable completion port threads: {1}\n",
            workerThreads, portThreads);

        ThreadPool.QueueUserWorkItem(new 
            WaitCallback(ThreadPoolTest.WorkItemMethod), mainEvent);
           
        // Since ThreadPool threads are background threads, 
        // wait for the work item to signal before ending Main.
        mainEvent.WaitOne(5000, false);
    }
}

class ThreadPoolTest
{
    // Maintains state information to be passed to EndWriteCallback.
    // This information allows the callback to end the asynchronous
    // write operation and signal when it is finished.
    class State
    {
        public FileStream     fStream;
        public AutoResetEvent autoEvent;

        public State(FileStream fStream, AutoResetEvent autoEvent)
        {
            this.fStream   = fStream;
            this.autoEvent = autoEvent;
        }
    }

    ThreadPoolTest() {}

    public static void WorkItemMethod(object mainEvent)
    {
        Console.WriteLine("\nStarting WorkItem.\n");
        AutoResetEvent autoEvent = new AutoResetEvent(false);

        // Create some data.
        const int ArraySize  = 10000;
        const int BufferSize =  1000;
        byte[] byteArray = new Byte[ArraySize];
        new Random().NextBytes(byteArray);

        // Create two files and two State objects. 
        FileStream fileWriter1 = 
            new FileStream(@"C:\Test1@##.dat", FileMode.Create, 
            FileAccess.ReadWrite, FileShare.ReadWrite, 
            BufferSize, true);
        FileStream fileWriter2 = 
            new FileStream(@"C:\Test2@##.dat", FileMode.Create, 
            FileAccess.ReadWrite, FileShare.ReadWrite, 
            BufferSize, true);
        State stateInfo1 = new State(fileWriter1, autoEvent);
        State stateInfo2 = new State(fileWriter2, autoEvent);

        // Asynchronously write to the files.
        fileWriter1.BeginWrite(byteArray, 0, byteArray.Length, 
            new AsyncCallback(EndWriteCallback), stateInfo1);
        fileWriter2.BeginWrite(byteArray, 0, byteArray.Length, 
            new AsyncCallback(EndWriteCallback), stateInfo2);

        // Wait for the callbacks to signal.
        autoEvent.WaitOne();
        autoEvent.WaitOne();

        fileWriter1.Close();
        fileWriter2.Close();
        Console.WriteLine("\nEnding WorkItem.\n");

        // Signal Main that the work item is finished.
        ((AutoResetEvent)mainEvent).Set();
    }

    static void EndWriteCallback(IAsyncResult asyncResult)
    {
        Console.WriteLine("Starting EndWriteCallback.");

        State stateInfo = (State)asyncResult.AsyncState;
        int workerThreads;
        int portThreads;
        try
        {
            ThreadPool.GetAvailableThreads(out workerThreads, 
                out portThreads);
            Console.WriteLine("\nAvailable worker threads: \t{0}" +
                "\nAvailable completion port threads: {1}\n",
                workerThreads, portThreads);

            stateInfo.fStream.EndWrite(asyncResult);

            // Sleep so the other thread has a chance to run
            // before the current thread ends.
            Thread.Sleep(1500);
        }
        finally
        {
            // Signal that the current thread is finished.
            stateInfo.autoEvent.Set();
            Console.WriteLine("Ending EndWriteCallback.");
        }
    }
}
Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Example
    Shared Sub Main()
        Dim mainEvent As New AutoResetEvent(False)
        Dim workerThreads As Integer 
        Dim portThreads As Integer 

        ThreadPool.GetMaxThreads(workerThreads, portThreads)
        Console.WriteLine(vbCrLf & "Maximum worker threads: " & _
            vbTab & "{0}" & vbCrLf & "Maximum completion port " & _
            "threads: {1}", workerThreads, portThreads)

        ThreadPool.GetAvailableThreads(workerThreads, portThreads)
        Console.WriteLine(vbCrLf & "Available worker threads: " & _
            vbTab & "{0}" & vbCrLf & "Available completion port " & _
            "threads: {1}" & vbCrLf, workerThreads, portThreads)

        ThreadPool.QueueUserWorkItem(AddressOf _
            ThreadPoolTest.WorkItemMethod, mainEvent)
           
        ' Since ThreadPool threads are background threads, 
        ' wait for the work item to signal before ending Main.
        mainEvent.WaitOne(5000, False)
    End Sub

End Class

Public Class ThreadPoolTest

    ' Maintains state information to be passed to EndWriteCallback.
    ' This information allows the callback to end the asynchronous
    ' write operation and signal when it is finished.
    Class State
        Public fStream As FileStream
        Public autoEvent As AutoResetEvent

        Public Sub New(aFileStream As FileStream, anEvent As AutoResetEvent)
            fStream   = aFileStream
            autoEvent = anEvent
        End Sub
    End Class   
    
    Private Sub New
    End Sub

    Shared Sub WorkItemMethod(mainEvent As Object)
    
        Console.WriteLine(vbCrLf & "Starting WorkItem." & vbCrLf)
        Dim autoEvent As New AutoResetEvent(False)

        ' Create some data.
        Const ArraySize As Integer  = 10000
        Const BufferSize As Integer =  1000
        Dim byteArray As Byte() = New Byte(ArraySize){}
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(byteArray)

        ' Create two files and two State objects. 
        Dim fileWriter1 As FileStream = _
            New FileStream("C:\Test1111.dat", FileMode.Create, _
            FileAccess.ReadWrite, FileShare.ReadWrite, _
            BufferSize, True)
        Dim fileWriter2 As FileStream = _
            New FileStream("C:\Test2222.dat", FileMode.Create, _
            FileAccess.ReadWrite, FileShare.ReadWrite, _
            BufferSize, True)
        Dim stateInfo1 As New State(fileWriter1, autoEvent)
        Dim stateInfo2 As New State(fileWriter2, autoEvent)

        ' Asynchronously write to the files.
        fileWriter1.BeginWrite(byteArray, 0, byteArray.Length, _
            AddressOf EndWriteCallback, stateInfo1)
        fileWriter2.BeginWrite(byteArray, 0, byteArray.Length, _
            AddressOf EndWriteCallback, stateInfo2)

        ' Wait for the callbacks to signal.
        autoEvent.WaitOne()
        autoEvent.WaitOne()

        fileWriter1.Close()
        fileWriter2.Close()
        Console.WriteLine(vbCrLf & "Ending WorkItem." & vbCrLf)

        ' Signal Main that the work item is finished.
        DirectCast(mainEvent, AutoResetEvent).Set()
    
    End Sub

    Shared Sub EndWriteCallback(asyncResult As IAsyncResult)
        Console.WriteLine("Starting EndWriteCallback.")

        Dim stateInfo As State = _
            DirectCast(asyncResult.AsyncState, State)
        Dim workerThreads As Integer 
        Dim portThreads As Integer 
        Try
            ThreadPool.GetAvailableThreads(workerThreads, portThreads)
            Console.WriteLine(vbCrLf & "Available worker " & _
                "threads:" & vbTab & "{0}" & vbCrLf & "Available " & _
                "completion port threads: {1}" & vbCrLf, _
                workerThreads, portThreads)

            stateInfo.fStream.EndWrite(asyncResult)

            ' Sleep so the other thread has a chance to run
            ' before the current thread ends.
            Thread.Sleep(1500)
        Finally
        
            ' Signal that the current thread is finished.
            stateInfo.autoEvent.Set()
            Console.WriteLine("Ending EndWriteCallback.")
        End Try
    
    End Sub
End Class

Uwagi

W GetMaxThreads przypadku zwracania zmienna określona przez workerThreads zawiera maksymalną liczbę wątków roboczych dozwolonych w puli wątków, a zmienna określona przez completionPortThreads element zawiera maksymalną liczbę asynchronicznych wątków we/wy dozwolonych w puli wątków.

Za pomocą GetAvailableThreads metody można określić rzeczywistą liczbę wątków w puli wątków w dowolnym momencie.

Za pomocą polecenia SetMaxThreads można ustawić maksymalną liczbę wątków roboczych i asynchronicznych wątków we/wy w puli wątków.

Można kolejkować tyle żądań puli wątków, jak zezwala pamięć systemowa. Jeśli istnieje więcej żądań niż wątki puli wątków, dodatkowe żądania pozostaną w kolejce, dopóki wątki puli wątków nie staną się dostępne.

Dotyczy

Zobacz też