Export (0) Print
Expand All

ThreadPool.GetMaxThreads Method

Retrieves the number of requests to the thread pool that can be active concurrently. All requests above that number remain queued until thread pool threads become available.

Namespace: System.Threading
Assembly: mscorlib (in mscorlib.dll)

public static void GetMaxThreads (
	out int workerThreads,
	out int completionPortThreads
)
public static void GetMaxThreads (
	/** @attribute OutAttribute() */ /** @ref */ int workerThreads, 
	/** @attribute OutAttribute() */ /** @ref */ int completionPortThreads
)
JScript does not support passing value-type arguments by reference.

Parameters

workerThreads

The maximum number of worker threads in the thread pool.

completionPortThreads

The maximum number of asynchronous I/O threads in the thread pool.

When GetMaxThreads returns, the variable specified by workerThreads contains the maximum number of worker threads allowed in the thread pool, and the variable specified by completionPortThreads contains the maximum number of asynchronous I/O threads allowed in the thread pool.

You can use GetAvailableThreads to determine the actual number of threads in the thread pool at any given time.

You can queue as many thread pool requests as system memory allows. If there are more requests than thread pool threads, the additional requests remain queued until thread pool threads become available.

The following code example shows how to retrieve a count of the maximum and available number of threads in the thread pool. A work item is queued that uses FileStream to asynchronously write to two files. The callback methods are timed to overlap. A worker thread handles the work item and, depending on the speed and number of processors on the computer, one or two completion port threads handle the write operations.

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

import System.*;
import System.IO.*;
import System.Security.Permissions.*;
import System.Threading.*;
import System.Threading.Thread;

// 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
{
    public static void main(String[] args)
    {
        AutoResetEvent mainEvent = new AutoResetEvent(false);
        int workerThreads = 0;
        int portThreads = 0;

        ThreadPool.GetMaxThreads(workerThreads, portThreads);
        Console.WriteLine("\nMaximum worker threads: \t{0}" + 
            "\nMaximum completion port threads: {1}",
            String.valueOf(workerThreads), String.valueOf(portThreads));
        ThreadPool.GetAvailableThreads(workerThreads, portThreads);
        Console.WriteLine("\nAvailable worker threads: \t{0}" + 
            "\nAvailable completion port threads: {1}\n", 
            String.valueOf(workerThreads), String.valueOf(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);
    } //main
} //Test

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;
        } //State
    } //State

    ThreadPoolTest()
    {
    } //ThreadPoolTest

    public static void WorkItemMethod(Object mainEvent)
    {
        Console.WriteLine("\nStarting WorkItem.\n");

        AutoResetEvent autoEvent = new AutoResetEvent(false);
      
        // Create some data.
        final int arraySize = 10000;
        final int bufferSize = 1000;
        ubyte byteArray[] = new ubyte[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);
        ThreadPoolTest test = new ThreadPoolTest();
        State stateInfo1 = test.new State(fileWriter1, autoEvent);
        State stateInfo2 = test.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();
    } //WorkItemMethod

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

        State stateInfo = ((State)(asyncResult.get_AsyncState()));
        int workerThreads = 0;
        int portThreads = 0;

        try {
            ThreadPool.GetAvailableThreads(workerThreads, portThreads);
            Console.WriteLine("\nAvailable worker threads: \t{0}" +
                "\nAvailable completion port threads: {1}\n",
                String.valueOf(workerThreads), String.valueOf(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.");
        }
    } //EndWriteCallback
} //ThreadPoolTest

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0

Community Additions

ADD
Show:
© 2014 Microsoft