ThreadPool.GetMaxThreads(Int32, Int32) Metódus
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Lekéri az egyidejűleg aktív szálkészlethez érkező kérések számát. A fenti kérések mindaddig várólistán maradnak, amíg a szálkészlet szálai elérhetővé nem válnak.
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 -> unitPublic Shared Sub GetMaxThreads (ByRef workerThreads As Integer, ByRef completionPortThreads As Integer)Paraméterek
- workerThreads
- Int32
A szálkészletben található feldolgozószálak maximális száma.
- completionPortThreads
- Int32
A szálkészlet aszinkron I/O-szálainak maximális száma.
Példák
Az alábbi példakód bemutatja, hogyan kérhető le a szálkészletben található szálak maximális és elérhető száma. Egy munkaelem várólistára kerül, amely két fájlba aszinkron írásra használható FileStream . A visszahívási metódusok átfedésre vannak időzve. A munkaszál kezeli a munkaelemet, és a számítógép processzorainak sebességétől és számától függően egy vagy két befejező portszál kezeli az írási műveleteket.
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
Megjegyzések
A visszaadott GetMaxThreads változó workerThreads a szálkészletben engedélyezett feldolgozószálak maximális számát tartalmazza, a megadott változó completionPortThreads pedig a szálkészletben engedélyezett aszinkron I/O-szálak maximális számát tartalmazza.
A metódus használatával GetAvailableThreads bármikor meghatározhatja a szálkészletben lévő szálak tényleges számát.
Ezzel SetMaxThreads megadhatja a munkaszálak és az aszinkron I/O-szálak maximális számát a szálkészletben.
A rendszermemória által lehetővé teszi, hogy annyi szálkészlet-kérést várólistára állítsunk, amennyit csak lehet. Ha több kérés van, mint a szálkészlet szálai, a további kérések várólistán maradnak, amíg a szálkészlet szálai elérhetővé nem válnak.
