ThreadPool.GetMaxThreads(Int32, Int32) メソッド

定義

名前空間:

System.Threading

アセンブリ:

System.Threading.ThreadPool.dll

ソース:

ThreadPool.Unix.cs

同時にアクティブにできるスレッド プールへの要求の数を取得します。 この数を超える要求はすべて、スレッド プール スレッドが使用可能になるまでキューに置かれたままになります。

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)

パラメーター

workerThreads

Int32

スレッド プール内のワーカー スレッドの最大数。

completionPortThreads

Int32

スレッド プール内の非同期 I/O スレッドの最大数。

例

次のコード例は、スレッド プール内のスレッドの最大数と使用可能な数の数を取得する方法を示しています。 を使用 FileStream して 2 つのファイルに非同期的に書き込む作業項目がキューに入れられます。 コールバック メソッドは重複するように設定されます。 ワーカー スレッドは作業項目を処理し、コンピューター上のプロセッサの速度と数に応じて、1 つまたは 2 つの完了ポート スレッドが書き込み操作を処理します。

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

注釈

が返されると GetMaxThreads 、 で workerThreads 指定された変数にはスレッド プールで許可されるワーカー スレッドの最大数が格納され、 で completionPortThreads 指定された変数にはスレッド プールで許可される非同期 I/O スレッドの最大数が含まれます。

メソッドを GetAvailableThreads 使用すると、任意の時点でスレッド プール内のスレッドの実際の数を確認できます。

を SetMaxThreads 使用して、スレッド プール内のワーカー スレッドと非同期 I/O スレッドの最大数を設定できます。

システム メモリで許容される数のスレッド プール要求をキューに登録できます。 スレッド プール スレッドよりも多くの要求がある場合、スレッド プール スレッドが使用可能になるまで、追加の要求はキューに残ります。

こちらもご覧ください

• SetMinThreads(Int32, Int32)
• GetMinThreads(Int32, Int32)
• GetAvailableThreads(Int32, Int32)
• SetMaxThreads(Int32, Int32)