Get-Process

Get-Process
    [[-Name] <String[]>]
    [-ComputerName <String[]>]
    [-Module]
    [-FileVersionInfo]
    [<CommonParameters>]

Get-Process
    [[-Name] <String[]>]
    [-IncludeUserName]
    [<CommonParameters>]

Get-Process
    -Id <Int32[]>
    [-IncludeUserName]
    [<CommonParameters>]

Get-Process
    -Id <Int32[]>
    [-ComputerName <String[]>]
    [-Module]
    [-FileVersionInfo]
    [<CommonParameters>]

Get-Process
    -InputObject <Process[]>
    [-IncludeUserName]
    [<CommonParameters>]

Get-Process
    -InputObject <Process[]>
    [-ComputerName <String[]>]
    [-Module]
    [-FileVersionInfo]
    [<CommonParameters>]

Das Cmdlet Get-Process ruft die Prozesse auf einem lokalen oder Remotecomputer ab.

Ohne Parameter ruft dieses Cmdlet alle Prozesse auf dem lokalen Computer ab. Sie können einen bestimmten Prozess auch durch Prozessname oder Prozess-ID (PID) angeben oder ein Prozessobjekt über die Pipeline an dieses Cmdlet übergeben.

Standardmäßig gibt dieses Cmdlet ein Prozessobjekt zurück, das detaillierte Informationen zum Prozess enthält und Methoden unterstützt, mit denen Sie den Prozess starten und beenden können. Sie können auch die Parameter des cmdlets Get-Process verwenden, um Dateiversionsinformationen für das Programm abzurufen, das im Prozess ausgeführt wird, und um die Module abzurufen, die der Prozess geladen hat.

Get-Process

Dieser Befehl ruft eine Liste aller aktiven Prozesse ab, die auf dem lokalen Computer ausgeführt werden. Eine Definition jeder Spalte finden Sie im Abschnitt Notizen.

Get-Process winword, explorer | Format-List *

Mit diesem Befehl werden alle verfügbaren Daten zu winword- und Explorer-Prozessen auf dem Computer abgerufen. Er verwendet den parameter Name, um die Prozesse anzugeben, aber der optionale Parametername wird weggelassen. Der Pipelineoperator | übergibt die Daten an das Format-List Cmdlet, das alle verfügbaren Eigenschaften * der Winword- und Explorer-Prozessobjekte anzeigt.

Sie können die Prozesse auch anhand ihrer Prozess-IDs identifizieren. Beispiel: Get-Process -Id 664, 2060.

Get-Process | Where-Object {$_.WorkingSet -gt 20000000}

Mit diesem Befehl werden alle Prozesse mit einem Arbeitssatz abgerufen, dessen Größe 20 MB übersteigt. Es verwendet das Get-Process Cmdlet, um alle ausgeführten Prozesse abzurufen. Der Pipelineoperator | übergibt die Prozessobjekte an das Where-Object Cmdlet, das nur das Objekt mit einem Wert von mehr als 20.000.000 Byte für die WorkingSet-Eigenschaft auswählt.

WorkingSet ist eine von vielen Eigenschaften von Prozessobjekten. Geben Sie Get-Process | Get-Memberein, um alle Eigenschaften anzuzeigen. Standardmäßig befinden sich die Werte aller Mengeneigenschaften in Byte, obwohl die Standardanzeige sie in Kilobyte und Megabyte auflistet.

$A = Get-Process
$A | Get-Process | Format-Table -View priority

Mit diesen Befehlen werden die Prozesse auf dem Computer basierend auf ihrer Prioritätsklasse in Gruppen aufgelistet. Der erste Befehl ruft alle Prozesse auf dem Computer ab und speichert sie dann in der variablen $A.

Der zweite Befehl leitet das in der -Variable gespeicherte $A-Objekt an das Get-Process-Cmdlet und dann an das Format-Table-Cmdlet weiter, das die Prozesse mit Hilfe der Ansicht Priorität aufbereitet.

Die Ansicht Priorität und andere Ansichten sind in den PS1XML-Formatdateien im PowerShell-Stammverzeichnis ($pshome) definiert.

Get-Process powershell -ComputerName S1, localhost | Format-Table `
    @{Label = "NPM(K)"; Expression = {[int]($_.NPM / 1024)}},
    @{Label = "PM(K)"; Expression = {[int]($_.PM / 1024)}},
    @{Label = "WS(K)"; Expression = {[int]($_.WS / 1024)}},
    @{Label = "VM(M)"; Expression = {[int]($_.VM / 1MB)}},
    @{Label = "CPU(s)"; Expression = {if ($_.CPU) {$_.CPU.ToString("N")}}},
    Id, MachineName, ProcessName -AutoSize

NPM(K) PM(K) WS(K) VM(M) CPU(s)   Id MachineName ProcessName
------ ----- ----- ----- ------   -- ----------- -----------
     6 23500 31340   142 1.70   1980 S1          powershell
     6 23500 31348   142 2.75   4016 S1          powershell
    27 54572 54520   576 5.52   4428 localhost   powershell

In diesem Beispiel werden Prozesse vom lokalen Computer und von einem Remotecomputer (S1) abgerufen. Die abgerufenen Prozesse werden an den Befehl weitergeleitet, der Format-Table der Standardausgabeanzeige die Get-Process hinzufügt.

Get-Process powershell -FileVersionInfo

ProductVersion   FileVersion      FileName
--------------   -----------      --------
6.1.6713.1       6.1.6713.1 (f... C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe

Dieser Befehl verwendet den FileVersionInfo-Parameter , um die Versionsinformationen für die powershell.exe Datei abzurufen, die das Hauptmodul für den PowerShell-Prozess ist.

Um diesen Befehl mit Prozessen auszuführen, die Sie unter Windows Vista und höheren Versionen von Windows nicht besitzen, müssen Sie PowerShell mit der Option Als Administrator ausführen öffnen.

Get-Process SQL* -Module

Dieser Befehl verwendet den parameter Module, um die Module abzurufen, die vom Prozess geladen wurden. Mit diesem Befehl werden die Module für die Prozesse abgerufen, deren Namen mit SQL beginnen.

Wenn Sie diesen Befehl unter Windows Vista und höheren Versionen von Windows mit Prozessen ausführen möchten, die Sie nicht besitzen, müssen Sie PowerShell mit der Option Als Administrator ausführen starten.

PS C:\> Get-Process powershell -IncludeUserName

Handles      WS(K)   CPU(s)     Id UserName            ProcessName
-------      -----   ------     -- --------            -----------
    782     132080     2.08   2188 DOMAIN01\user01     powershell

$p = Get-WmiObject Win32_Process -Filter "name='powershell.exe'"
$p.GetOwner()

__GENUS          : 2
__CLASS          : __PARAMETERS
__SUPERCLASS     :
__DYNASTY        : __PARAMETERS
__RELPATH        :
__PROPERTY_COUNT : 3
__DERIVATION     : {}
__SERVER         :
__NAMESPACE      :
__PATH           :
Domain           : DOMAIN01
ReturnValue      : 0
User             : user01

Der erste Befehl zeigt, wie der Besitzer eines Prozesses gefunden wird. Für den Parameter IncludeUserName sind erhöhte Benutzerrechte erforderlich (Als Administrator ausführen). Die Ausgabe zeigt, dass der Besitzer Domain01\user01 ist.

Der zweite und dritte Befehl sind eine weitere Möglichkeit, den Besitzer eines Prozesses zu finden.

Der zweite Befehl verwendet Get-WmiObject, um den PowerShell-Prozess abzurufen. Es wird in der Variablen $p gespeichert.

Der dritte Befehl verwendet die GetOwner-Methode, um den Besitzer des Prozesses in $p abzurufen. Die Ausgabe zeigt, dass der Besitzer Domain01\user01 ist.

Get-Process powershell

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
308      26        52308      61780   567     3.18   5632 powershell
377      26        62676      63384   575     3.88   5888 powershell

Get-Process -Id $PID

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
396      26        56488      57236   575     3.90   5888 powershell

Diese Befehle zeigen, wie Sie die $PID automatische Variable verwenden, um den Prozess zu identifizieren, der die aktuelle PowerShell-Sitzung hostet. Sie können diese Methode verwenden, um den Hostprozess von anderen PowerShell-Prozessen zu unterscheiden, die Sie möglicherweise beenden oder schließen möchten.

Der erste Befehl ruft alle PowerShell-Prozesse in der aktuellen Sitzung ab.

Der zweite Befehl ruft den PowerShell-Prozess ab, der die aktuelle Sitzung hosten soll.

Get-Process | Where-Object {$_.mainWindowTitle} | Format-Table Id, Name, mainWindowtitle -AutoSize

Dieser Befehl ruft alle Prozesse mit einem Hauptfenstertitel ab und zeigt sie in einer Tabelle mit der Prozess-ID und dem Prozessnamen an.

Die Eigenschaft mainWindowTitle ist nur eine von vielen nützlichen Eigenschaften des Process-Objekts, das Get-Processzurückgibt. Um alle Eigenschaften anzuzeigen, führen Sie die Ergebnisse eines Get-Process Befehls an das Get-Member Cmdlet Get-Process | Get-Memberweiter.

Dieses Cmdlet unterstützt die allgemeinen Parameter -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction und -WarningVariable. Weitere Informationen findest du unter about_CommonParameters.

Sie können ein Prozessobjekt an dieses Cmdlet weiterleiten.

Standardmäßig gibt dieses Cmdlet ein System.Diagnostics.Process-Objekt zurück. Wenn Sie den FileVersionInfo-Parameter verwenden, wird ein System.Diagnostics.FileVersionInfo-Objekt zurückgegeben. Wenn Sie den Module-Parameter ohne den FileVersionInfo-Parameter verwenden, wird ein System.Diagnostics.ProcessModule-Objekt zurückgegeben.

• Sie können sich auch über die integrierten Aliase ps und gps auf dieses Cmdlet beziehen. Weitere Informationen finden Sie unter about_Aliases.
• Auf Computern, auf denen eine 64-Bit-Version von Windows ausgeführt wird, erhält die 64-Bit-Version von PowerShell nur 64-Bit-Prozessmodule, und die 32-Bit-Version von PowerShell erhält nur 32-Bit-Prozessmodule.
• Sie können die Eigenschaften und Methoden des WMI-Objekts (Windows Management Instrumentation) Win32_Process in PowerShell verwenden. Weitere Informationen finden Sie unter Get-WmiObject und im WMI SDK.
• Die Standardanzeige eines Prozesses ist eine Tabelle, die die folgenden Spalten enthält. Eine Beschreibung aller Eigenschaften von Prozessobjekten finden Sie unter Prozesseigenschaften in der MSDN Library.
  • Handles: Die Anzahl der Handles, die der Prozess geöffnet hat.
  • NPM(K): Die Menge an nicht ausgelagertem Speicher, die der Prozess verwendet, in Kilobyte.
  • PM(K): Die Menge an auslagerungsfähigem Speicher, die der Prozess verwendet, in Kilobyte.
  • WS(K): Die Größe des Arbeitssatzes des Prozesses in Kilobyte. Der Arbeitssatz besteht aus Speicherseiten, auf die zuvor vom Prozess verwiesen wurde.
  • VM(M): Die Menge an virtuellem Speicher, die der Prozess verwendet, in Megabyte. Der virtuelle Speicher umfasst den Speicher der Auslagerungsdateien auf dem Datenträger.
  • CPU(s): Die Prozessorzeit, die der Prozess auf allen Prozessoren verbraucht hat, in Sekunden.
  • ID: Die Prozess-ID (PID) des Prozesses.
  • ProcessName: Der Name des Prozesses. Erläuterungen zu den Konzepten im Zusammenhang mit Prozessen finden Sie im Glossar im Hilfe- und Supportcenter und in der Hilfe für Task Manager.
• Sie können auch die integrierten alternativen Ansichten der Prozesse verwenden, die mit Format-Tableverfügbar sind, z. B. StartTime - und Priority. Außerdem können Sie eigene Ansichten entwerfen.