Linux" Top " Befehl für Windows Powershell?

Dies ist ein einfacher Einzeiler, der auch die Beschriftungen oben hält:

While(1) {ps | sort -des cpu | select -f 15 | ft -a; sleep 1; cls}

Dies funktioniert, da das Formatieren der Tabelle ohne Parameter nur die Standardtabelle zeichnet. autosize wird verwendet, um die Spaltenbreite automatisch anzupassen, damit alle Daten auf den Bildschirm passen.

Aufschlüsselung der verkürzten Befehle:

• select -f: Abkürzung für -first
• ft: Abkürzung für Format-Table
• -a: Abkürzung für -autosize
• sleep: standardmäßig mit Sekunden -

Es gibt nichts, was ich davon in einer einzelnen Cmdlet-Form weiß, aber wie Sie sagen, Skripte sind einfach zu schreiben, um sie zu emulieren.

while (1) { ps | sort -desc cpu | select -first 30; sleep -seconds 2; cls }

Eine ähnliche Lösung wie andere, aber mit Get-Counter anstelle von Get-Process:

While(1) {  $p = get-counter '\Process(*)\% Processor Time'; cls; $p.CounterSamples | sort -des CookedValue | select -f 15 | ft -a}

Beispielausgabe:

Path                                                      InstanceName              CookedValue
----                                                      ------------              -----------
\\server_name\process(_total)\% processor time                 _total               4806.03969127454
\\server_name\process(idle)\% processor time                   idle                 1103.7573538257
\\server_name\process(program2)\% processor time               program              749.692930701698
\\server_name\process(program5)\% processor time               program              563.424255927765
\\server_name\process(program1)\% processor time               program              535.714866291973
\\server_name\process(program6)\% processor time               program              455.665518455242
\\server_name\process(program3)\% processor time               program              426.416718284128
\\server_name\process(program)\% processor time                program              395.628507577693
\\server_name\process(program4)\% processor time               program              335.591496700144
\\server_name\process(microsoftedgecp2)\% processor time       microsoftedgecp      129.310484967028
\\server_name\process(system)\% processor time                 system               80.0493478367316
\\server_name\process(chrome8)\% processor time                chrome               1.53941053532176

Ich habe die meisten anderen Lösungen hier mit Get-Process gefunden, um die gesamte CPU-Zeit seit Beginn des Prozesses zu melden, was auf meinem Server, der rund um die Uhr geöffnet bleibt, nicht nützlich war, wobei das oberste Ergebnis immer svchost und system in Millionen von Sekunden.

• Ein wahres top oder Task-Manager-Äquivalent würde einen Schnappschuss der CPU-Auslastung geben, die kürzlich über einige feste aufgezeichnet wurde time and Get-Counter liefert das. Ich dachte, diese Alternative ist einen Beitrag wert, da diese Frage immer noch das beste Google-Ergebnis für ist powershell top.

Basierend auf Beispiel 13 aus dem Get-Counter docs, eine Aufschlüsselung des Befehls:

• While(1) {: Erzeugt eine Schleife

• get-counter '\Process(*)\% Processor Time': Wählt CPU % - Daten aus, deren Rückgabe erheblich dauert, sodass keine Notwendigkeit besteht sleep

• cls: Klar für den Neuen Tabelle

• sort -des CookedValue: Sortieren Sie die größten oben nach CookedValue [Feld, an dem wir interessiert sind]
• select -f 15: Erste 15 Anzeigen
• ft -a: Anzeige in formatierter Tabelle

Bietet bei jedem Update schöne Überschriften oben, ohne die gesamte Konsole löschen zu müssen:

$saveY = [console]::CursorTop
$saveX = [console]::CursorLeft

while ($true) {
  Get-Process | Sort -Descending CPU | Select -First 30;
  Sleep -Seconds 2;
  [console]::setcursorposition($saveX,$saveY+3)
}

Sie können versuchen NTop (binaries), eine htop Alternative für Windows, mit Vi - emulation für Windows:

• Befehlszeilenoptionen:
  • C: Verwenden Sie monochromes Farbschema
  • h: Hilfe anzeigen
  • p <PID>: Zeige nur die angegebenen PIDs
  • s <COLUMN>: Sortieren nach dieser Spalte
  • u <USERNAME>: Nur Anzeigeprozesse gehören dazu an diesen Benutzer
  • v: Druckversion
    
    
• , Interaktive Befehle:
  • ↑, ↓, PageUp, PageDn, j, k: Scrollen Sie durch die Prozessliste
  • STRG+← oder →: Ändern Sie die Prozesssortierung Spalte
  • g: Gehe zum Anfang der Prozessliste
  • G: Gehe zum Ende der Prozessliste
  • Raum: Markieren Sie einen ausgewählten Prozess
  • U: Untag alle markierten Prozesse
  • K: Töte alle markierten Prozesse
  • I: Invertieren Sie die Sortierreihenfolge
  • F: Folgen Prozess
    Wenn die Sortierreihenfolge bewirkt, dass der aktuell ausgewählte Prozess in der Liste zu bewegen, machen Sie die Auswahlleiste folgen (Bewegen des Cursors manuell automatisch deaktiviert diese Funktion).
  • n: Weiter auf der Suche
  • N: Zurück auf der Suche
    
    
• Vi Befehle:
  • :exec <command>: Führt den angegebenen Windows-Befehl
  • :kill <PIDs>: Töte alle gegeben Prozesse
  • :q oder :quit: Beenden NTop
  • /<PATTERN> oder :search <PATTERN>: Machen Sie eine Suche
  • :sort <COLUMN>: Sortieren Sie die Prozessliste nach der angegebenen Spalte
  • :tree: Prozessbaum anzeigen

Mir ist kein PowerShell-Cmdlet bekannt, das die Funktionalität bietet, aber hier ist ein externer Freeware-Befehl, der genau das tut, was Sie wollen, Mark Russinovichs pslist aus der Sysinternals - Suite:

• pslist stellt eine Liste der ausgeführten Prozesse in einer konfigurierbaren Ansicht bereit
• pslist -s bietet die gewünschte kontinuierliche Aktualisierung mit einer Standard-Aktualisierungsrate von einmal pro Sekunde

Ich bevorzuge Marks GUI Process Explorer, aber pslist ist praktisch für Konsolensitzung.

Dies ist nur ein etwas schönerer Weg, da Sie die Überschriften jedes Mal oben sehen:

While (1) {
  Ps | Sort -desc cpu | Select -first 30; Sleep -seconds 2; Cls;
  Write-Host "Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName";
  Write-Host "-------  ------    -----      ----- -----   ------     -- -----------"
}

Dies ist nur ein etwas schönerer Weg, da Sie die Überschriften jedes Mal oben sehen können

Speichern Sie Folgendes in mytop.ps1 in einem Ordner in Ihrer Umgebungsvariablen PATH und verwenden Sie dann eines der folgenden Elemente in einer PowerShell-Konsole:

• mytop: [Defautl] Sortiert nach Memory und zeigt die ersten 30 Zeilen
• mytop CPU 50: Sortiert nach ' CPU ' und zeigt die ersten 50 Zeilen an.
• While(1) {$p = myTop Memory 50; cls; $p}: Aktualisiert jede Sekunde

##################################################
#  Linux top equivalent in PowerShell
##################################################
if ($args[0] -eq $null) {
  $SortCol = "Memory"
} else {
  $SortCol = $args[0]
}

if ($args[1] -eq $null) {
  $Top = 30
} else {
  $Top = $args[1]
}


$LogicalProcessors = (Get-WmiObject -class Win32_processor -Property NumberOfLogicalProcessors).NumberOfLogicalProcessors;

function myTopFunc ([string]$SortCol = "Memory", [int]$Top = 30) {
  ## Check user level of PowerShell
  if (
    ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()
    ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
  )
  {
    $procTbl = get-process -IncludeUserName | select ID, Name, UserName, Description, MainWindowTitle
  } else {
    $procTbl = get-process | select ID, Name, Description, MainWindowTitle
  }

  Get-Counter `
    '\Process(*)\ID Process',`
    '\Process(*)\% Processor Time',`
    '\Process(*)\Working Set - Private'`
    -ea SilentlyContinue |
  foreach CounterSamples |
  where InstanceName -notin "_total","memory compression" |
  group { $_.Path.Split("\\")[3] } |
  foreach {
    $procIndex = [array]::indexof($procTbl.ID, [Int32]$_.Group[0].CookedValue)
    [pscustomobject]@{
      Name = $_.Group[0].InstanceName;
      ID = $_.Group[0].CookedValue;
      User = $procTbl.UserName[$procIndex]
      CPU = if($_.Group[0].InstanceName -eq "idle") {
        $_.Group[1].CookedValue / $LogicalProcessors
        } else {
        $_.Group[1].CookedValue
      };
      Memory = $_.Group[2].CookedValue / 1KB;
      Description = $procTbl.Description[$procIndex];
      Title = $procTbl.MainWindowTitle[$procIndex];
    }
  } |
  sort -des $SortCol |
  select -f $Top @(
    "Name", "ID", "User",
    @{ n = "CPU"; e = { ("{0:N1}%" -f $_.CPU) } },
    @{ n = "Memory"; e = { ("{0:N0} K" -f $_.Memory) } },
    "Description", "Title"
  ) | ft -a
}

myTopFunc -SortCol $SortCol -top $Top

Beispielausgabe:

Name                               ID User                         CPU   Memory       Description
----                               -- ----                         ---   ------       -----------
sqlservr                         7776 NT SERVICE\MSSQLSERVER       0.0%  19,001,488 K SQL Server Windows NT - 64 Bit
python                          12872 NA\user1                     0.0%  2,159,796 K  Python
svchost                          3328 NT AUTHORITY\SYSTEM          1.6%  1,022,080 K  Host Process for Windows Services
onedrive                        11872 NA\user1                     0.0%  423,396 K    Microsoft OneDrive
python                          13764 NA\user1                     0.0%  304,608 K    Python
chrome                          21188 NA\user1                     0.0%  250,624 K    Google Chrome
python                          28144 NA\user2                     0.0%  225,824 K    Python
code                            21384 NA\user1                     0.0%  211,160 K    Visual Studio Code
code                            27412 NA\user2                     0.0%  185,892 K    Visual Studio Code
ssms                            18288 NA\user1                     29.5% 155,452 K    SSMS
chrome                           7536 NA\user1                     0.0%  154,124 K    Google Chrome
code                            21652 NA\user1                     0.0%  149,900 K    Visual Studio Code
explorer                         3204 NA\user1                     0.0%  134,340 K    Windows Explorer
python                          11712 NA\user1                     0.0%  130,624 K    Python
chrome                          21588 NA\user1                     0.0%  107,448 K    Google Chrome
code                            10152 NA\user1                     0.0%  100,880 K    Visual Studio Code
code                            20232 NA\user2                     0.0%  99,124 K     Visual Studio Code
python                          22184 NA\user1                     0.0%  94,800 K     Python
code                            14828 NA\user1                     0.0%  84,872 K     Visual Studio Code
searchui                        13344 NA\user1                     0.0%  78,260 K     Search and Cortana application
com.docker.service              10644 NT AUTHORITY\SYSTEM          0.0%  77,332 K     Docker.Service

Zusätzliche Gutschrift für Antworten von rokumaru, LotPings, und DBADon

Dies kann auch den Trick machen:

function htopish {
  Param (
  [Parameter(Position=1)] [Alias("l")]
  [int]$TotalList=24,
  [Parameter(Position=2)] [Alias("r")]
  [int]$Invertal=1
  )
  Begin {}
  Process {
    While ($true) {
      $CounterSamples = Get-Counter '\Process(*)\ID Process','\Process(*)\% Processor Time','\Process(*)\Working Set' | Select-Object -Expand CounterSamples
      Clear-Host
      $CounterSamples | Group-Object { Split-Path $_.Path } | Where-Object {$_.Group[1].InstanceName -notmatch "^Idle|_Total|System$"} | Sort-Object -Property {$_.Group[1].CookedValue} -Descending | Select-Object -First $TotalList | Format-Table @{Name="ProcessId";Expression={$_.Group[0].CookedValue}},@{Name="ProcessorUsage";Expression={[System.Math]::Round($_.Group[1].CookedValue/100/$env:NUMBER_OF_PROCESSORS,4)}},@{Name="ProcessName";Expression={$_.Group[1].InstanceName}},@{Name="WorkingSet";Expression={[System.Math]::Round($_.Group[2].CookedValue/1MB,4)}}
    Sleep -Seconds $Invertal
  }
  }
  End {}
}

• Function stützt sich auf die Get-Counter Samples und gibt die ProcessId,ProcessName, ProcessorUsage, und WorkingSet.
• Dieses Zählerbeispiel könnte weiter verbessert werden, um User und CommandLine in die Ausgabe aufzunehmen, aber ich habe noch keinen performanten Weg gefunden.

Dieser Kommentar von Mark sollte mehr Empfehlung bekommen, weil er fast genau das tut, was die Frage war und es funktioniert:

• Bietet die schönen Überschriften an der Spitze mit jedem Update, ohne dass die gesamte Konsole zu löschen.

  $saveY = [console]::CursorTop
  $saveX = [console]::CursorLeft      
  
  while ($true) {
    Get-Process | Sort -Descending CPU | Select -First 30;
    Sleep -Seconds 2;
    [console]::setcursorposition($saveX,$saveY+3)
  }
  

Ich möchte darauf hinweisen, dass Sie, wenn Sie eine Linux-ähnliche Umgebung für Windows möchten, Cygwin verwenden können, da dies eine Linux-ähnliche Umgebung zu Windows bringt, wo Sie fast jeden Befehl verwenden können.

Ich schrieb wttop, ein top für das neue Windows-Terminal, das über Powershell gestartet werden kann.

Wenn Sie nach Prozessen filtern möchten, verwenden Sie findstr:

while (1) { Ps |Findstr explorer | Sort -desc cpu | Select -first 30; Sleep -seconds 2; Cls }

Möglicherweise möchten Sie Resource Monitor von Powershell aus über resmon starten, das über geschlossen werden kann.+ F4, Fokus zurück zum Powershell-Terminal schalten.

Etwas anderes zu betrachten ist SysInternals

• Dies sind Befehlszeilentools zum Speichern aller Prozesse zusammen mit Process Monitor und Process Explorer.

Der folgende Befehl gibt die Top-10-CPU-Auslastung an, wobei die Ausgabe alle 5 Sekunden aktualisiert wird:

while(1) {
  Ps | Sort-Object -Property CPU -Descending | Select -First 10
  Write-Host "output will be refreshed in 5 sec's `n `n Handles NPM(K) PM(K) WS(K) CPU(s) Id SI ProcessName"
  Sleep -Seconds 5
}

Um top direkt von cmd aus auszuführen, müssen Sie %WinDir%\top.bat mit diesem Code erstellen:

@echo off

Cls && @echo TOP Program initialisation. Please Wait...

Powershell -ExecutionPolicy unrestricted -command "& {
  Cls
  While(1) { Ps | Sort -des CPU | Select -f 35 | Ft -a; sleep 2; Cls }
}"