ThreadPool.GetMaxThreads(Int32, Int32) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ruft die Anzahl der Anforderungen für den Threadpool ab, die gleichzeitig aktiv sein können. Alle über diese Zahl hinausgehenden Anforderungen bleiben in der Warteschlange, bis die Threads des Threadpools verfügbar sind.
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)
Parameter
- workerThreads
- Int32
Die maximale Anzahl der Arbeitsthreads im Threadpool.
- completionPortThreads
- Int32
Die maximale Anzahl asynchroner E/A-Threads im Threadpool.
Beispiele
Das folgende Codebeispiel zeigt, wie Sie die Anzahl der maximalen und verfügbaren Threads im Threadpool abrufen. Ein Arbeitselement wird in eine Warteschlange gestellt, die verwendet, FileStream
um asynchron in zwei Dateien zu schreiben. Die Rückrufmethoden werden auf Überlappung zeitiert. Ein Workerthread verarbeitet das Arbeitselement, und je nach Geschwindigkeit und Anzahl der Prozessoren auf dem Computer verarbeiten ein oder zwei Abschlussportthreads die Schreibvorgänge.
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
Hinweise
Bei GetMaxThreads rückgaben enthält die von workerThreads
angegebene Variable die maximale Anzahl von Workerthreads, die im Threadpool zulässig sind, und die von completionPortThreads
angegebene Variable enthält die maximale Anzahl asynchroner E/A-Threads, die im Threadpool zulässig sind.
Sie können die GetAvailableThreads -Methode verwenden, um die tatsächliche Anzahl von Threads im Threadpool zu einem bestimmten Zeitpunkt zu bestimmen.
Sie können die SetMaxThreads maximale Anzahl von Workerthreads und asynchronen E/A-Threads im Threadpool festlegen.
Sie können so viele Threadpoolanforderungen in eine Warteschlange stellen, wie der Systemspeicher zulässt. Wenn mehr Anforderungen als Threadpoolthreads vorhanden sind, bleiben die zusätzlichen Anforderungen in der Warteschlange, bis Threadpoolthreads verfügbar werden.