ThreadPool.GetAvailableThreads メソッド

2008-03-28

スレッドプールスレッドの最大数 (GetMaxThreads から返される) と現在アクティブなスレッドの数との差を取得します。

Public Shared Sub GetAvailableThreads( _
   <Out()> ByRef workerThreads As Integer, _   <Out()> ByRef completionPortThreads As Integer _)
[C#]
public static void GetAvailableThreads(   out intworkerThreads,   out intcompletionPortThreads);
[C++]
public: static void GetAvailableThreads(   [   Out] int* workerThreads,   [   Out] int* completionPortThreads);
[JScript]
public static function GetAvailableThreads(
   workerThreads : int,completionPortThreads : int);

パラメータ

workerThreads
使用できるワーカースレッドの数。
completionPortThreads
使用できる非同期 I/O スレッドの数。

解説

GetAvailableThreads を呼び出すと、 workerThreads に指定した変数には、追加で開始できるワーカースレッドの数が格納され、 completionPortThreads に指定した変数には、追加で開始できる非同期 I/O スレッドの数が格納されます。

使用できるスレッドがない場合、追加のスレッドプールの要求は、スレッドプールスレッドが使用可能になるまで、キューに置かれたままとなります。

使用例

[Visual Basic, C#, C++] スレッドプール内の最大スレッド数と使用できるスレッド数のカウントを取得する方法の例を次に示します。この例では、 FileStream を使用して 2 つのファイルに非同期的に書き込みを行うための作業項目がキューに置かれます。また、コールバックメソッドは、オーバーラップするように時間設定されます。作業項目はワーカースレッドによって処理され、コンピュータ上のプロセッサの速度と数に応じて、1 つまたは 2 つの完了ポートスレッドが書き込み操作を処理します。

 
Imports Microsoft.VisualBasic
Imports System
Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

' Request permission to create two data files.
<Assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, _
    All := "C:\Test1111.dat")>
<Assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, _
    All := "C:\Test2222.dat")>

Public Class Test

    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

[C#] 
using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

// Request permission to create two data files.
[assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, 
    All = @"C:\Test1@##.dat")]
[assembly: FileIOPermissionAttribute(SecurityAction.RequestMinimum, 
    All = @"C:\Test2@##.dat")]

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.");
        }
    }
}

[C++] 
#using <mscorlib.dll>
using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Request permission to create two data files.
[assembly: FileIOPermissionAttribute(SecurityAction::RequestMinimum, 
    All = "C:\\Test1#@@.dat")];
[assembly: FileIOPermissionAttribute(SecurityAction::RequestMinimum, 
    All = "C:\\Test2#@@.dat")];

__gc 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.
    __gc class State
    {
    public:
        FileStream*     fStream;
        AutoResetEvent* autoEvent;

        State(FileStream* fStream, AutoResetEvent* autoEvent)
        {
            this->fStream   = fStream;
            this->autoEvent = autoEvent;
        }
    };

    ThreadPoolTest() {}

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

        State* stateInfo = 
            dynamic_cast<State*>(asyncResult->AsyncState);
        int workerThreads;
        int portThreads;
        try
        {
            ThreadPool::GetAvailableThreads(&workerThreads, 
                &portThreads);
            Console::WriteLine(S"\nAvailable worker threads: \t{0}" 
                S"\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(S"Ending EndWriteCallback.");
        }
    }

public:
    static void WorkItemMethod(Object* mainEvent)
    {
        Console::WriteLine(S"\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(0, &ThreadPoolTest::EndWriteCallback),
            stateInfo1);
        fileWriter2->BeginWrite(byteArray, 0, byteArray->Length, 
            new AsyncCallback(0, &ThreadPoolTest::EndWriteCallback),
            stateInfo2);

        // Wait for each callback to finish.
        autoEvent->WaitOne();
        autoEvent->WaitOne();

        fileWriter1->Close();
        fileWriter2->Close();
        Console::WriteLine(S"\nEnding WorkItem.\n");

        // Signal Main that the work item is finished.
        dynamic_cast<AutoResetEvent*>(mainEvent)->Set();
    }
};

void main()
{
    AutoResetEvent* mainEvent = new AutoResetEvent(false);
    int workerThreads;
    int portThreads;

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

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

    ThreadPool::QueueUserWorkItem(new WaitCallback(0, 
        &ThreadPoolTest::WorkItemMethod), mainEvent);

    // Since ThreadPool threads are background threads, 
    // wait for the work item to signal before ending main().
    mainEvent->WaitOne(5000, false);
}

[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタボタンをクリックします。

必要条件

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

参照

次の方法で共有

ThreadPool.GetAvailableThreads メソッド

パラメータ

解説

使用例

必要条件

参照

その他のリソース