Comando "Top" di Linux per Windows Powershell?


61

Sto cercando un cmdlet di PowerShell in grado di fornire funzionalità simili all'app Top di Linux. Qualcosa che si aggiorna ad un determinato intervallo e visualizza l'elenco dei processi con CPU% util.

Ho visto degli script che elencano l'utilizzo della CPU% in un ciclo, ma qualcosa come top sarebbe molto più utile dato che abbiamo impostato l'accesso SSH / Powershell per la gestione (preferisco ancora una shell putty!)


Questo rientra esattamente nella categoria di domande di superuser.com .

Fantastico, non ti sei reso conto che il sito esisteva! (Sono principalmente uno sviluppatore C #)

3
La proprietà CPU sull'oggetto processo non è la percentuale della CPU, è il tempo totale della CPU dall'inizio del processo.

Risposte:


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

Questa è una semplice fodera che manterrà anche le etichette in alto.

Questo funziona perché la formattazione della tabella senza parametri disegna semplicemente la tabella predefinita. il ridimensionamento automatico viene utilizzato per regolare automaticamente la larghezza della colonna in modo che tutti i dati possano adattarsi allo schermo.

Ecco una ripartizione dei comandi abbreviati utilizzati

  • select -f è una scorciatoia per -first
  • ft è una scorciatoia per Format-Table
  • -a è una scorciatoia per -autosize
  • sleep utilizza automaticamente i secondi

2
CPUin psè il numero di secondi di utilizzo totale, non% CPU. Quindi questo non è così utile.
Artyom,

26

Non c'è nulla che io sappia di ciò in forma di singolo cmdlet, ma come dici tu, gli script sono facili da scrivere per emulare top.

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

abbastanza vicino - posso modificarlo da qui ... bene, fatto! (Sono uno sviluppatore C #, ma gestisco anche i nostri server - quindi risalendo la curva di PowerShell ...)

se vuoi saperne di più - ad esempio - dai un'occhiata a www.poshcode.org
x0n

@TimAtVenturality - Puoi avvolgere lo script come una funzione con parametri per replicare più da vicino top.
Joe Internet

18

Una soluzione simile alle altre, ma usando Get-Counter invece di Get-Process.

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

Uscita campione:

Path                                                      InstanceName              CookedValue
----                                                      ------------              -----------
\\server_name\process(_total)\% processor time                 _total               4806.03969127454
\\server_name\process(idle)\% processor time                   idle                 1103.7573538257
\\server_name\process(program#2)\% processor time              program              749.692930701698
\\server_name\process(program#5)\% processor time              program              563.424255927765
\\server_name\process(program#1)\% processor time              program              535.714866291973
\\server_name\process(program#6)\% processor time              program              455.665518455242
\\server_name\process(program#3)\% processor time              program              426.416718284128
\\server_name\process(program)\% processor time                program              395.628507577693
\\server_name\process(program#4)\% processor time              program              335.591496700144
\\server_name\process(microsoftedgecp#2)\% processor time      microsoftedgecp      129.310484967028
\\server_name\process(system)\% processor time                 system               80.0493478367316
\\server_name\process(chrome#8)\% processor time               chrome               1.53941053532176

Ho trovato la maggior parte delle altre soluzioni qui usando get-process riportano il tempo totale della CPU dall'inizio del processo. Non è stato utile sul mio server che rimane attivo 24 ore su 24, 7 giorni su 7, dove il risultato migliore è stato sempre giusto svchoste systemmilioni di secondi. Un topequivalente vero o Task Manager fornirebbe un'istantanea dell'utilizzo della CPU registrato di recente in un determinato periodo di tempo e Get-Counter lo fornisce. Poiché questo post di Superuser è ancora il miglior risultato di Google per "powerhell top", ho pensato che questa alternativa valesse la pena contribuire.

Il mio comando si basa sull'esempio 13 dei documenti Get-Counter: https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Diagnostics/Get-Counter .
Ecco una suddivisione del one-liner in modo da poterlo modificare più facilmente in base alle tue esigenze:

  • While(1) { lo avvolge e basta
  • get-counter '\Process(*)\% Processor Time'seleziona i dati% CPU. Questo comando sembra impiegare molto tempo per tornare, quindi non è necessariosleep
  • cls deselezionare per il nuovo tavolo
  • sort -des CookedValue CookedValue è il campo in cui siamo testati, in ordine di mettere il più grande in cima
  • select -f 15 visualizzare prima 15
  • ft -a visualizzare in una tabella formattata

4
Questa è la risposta migliore: Get-Counterti dà la CPU "istantanea", piuttosto che il tempo cumulativo della CPU da ps. Migliore formattazione : Get-Counter '\Process(*)\% Processor Time' | Select-Object -ExpandProperty countersamples| Select-Object -Property instancename, cookedvalue| ? {$_.instanceName -notmatch "^(idle|_total|system)$"} | Sort-Object -Property cookedvalue -Descending| Select-Object -First 25| ft InstanceName,@{L='CPU';E={($_.Cookedvalue/100/$env:NUMBER_OF_PROCESSORS).toString('P')}} -AutoSize
pjhsea,

6

Fornisce le belle intestazioni in alto con ogni aggiornamento senza la necessità di cancellare l'intera console.

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

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

5

Non sono a conoscenza di un cmdlet di PowerShell che fornisce la funzionalità. C'è un comando esterno freeware che fa quello che vuoi. Guarda la pslist di Mark Russinovich dalla suite Sysinternals. Pslist fornisce un elenco di processi in esecuzione in una vista configurabile. "pslist -s" fornisce il tipo di aggiornamento continuo desiderato, con una frequenza di aggiornamento predefinita di una volta al secondo.

Preferisco usare Mark Explorer GUI Process Explorer, ma pslist è utile per le sessioni della console.

La home page di Sysinternals è qui: http://technet.microsoft.com/en-us/sysinternals

Dennis


2
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 "-------  ------    -----      ----- -----   ------     -- -----------"}

Questo è solo un modo un po 'più bello, come puoi vedere le voci in cima ogni volta


1

Inoltre, voglio sottolineare che se desideri un ambiente simile a Linux per Windows puoi usare Cygwin. Porta l'ambiente Linux a Windows. Puoi usare quasi tutti i comandi. Non sono sicuro di quanto ti sia utile.

http://www.cygwin.com/


1

Questo può anche fare il trucco:

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 {}
}

La funzione si basa sui Get-Countercampioni e genererà ProcessId,ProcessName,ProcessorUsagee WorkingSet. Questo esempio di contatore potrebbe essere ulteriormente migliorato per includere User, CommandLinenell'output, ma non ho ancora elaborato un modo performante per farlo.


1

Questo commento di Mark dovrebbe ricevere più raccomandazioni, perché fa quasi esattamente quale fosse la domanda e funziona:

Fornisce le belle intestazioni in alto con ogni aggiornamento senza la necessità di cancellare l'intera console.

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

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

(link al commento: https://superuser.com/a/770455/989044 )

Dovresti creare un modulo semplice per esso e ospitare su github o fornirlo con choco. Penso che dovrebbe essere un modulo standart in primo luogo, perché è fortemente cercato su Google e ci sono tutti i tipi di soluzioni alternative, ma nessuno di loro è così elegante e vicino al comando top di Linux.

Ci scusiamo per averlo pubblicato in questo modo, ma a causa delle regole di avvertimento qui è impossibile commentare o prendere nota senza circa 50 karma o giù di lì.


0

Per eseguire top direttamente da cmd devi creare il file% WINDIR% \ top.bat con questo codice:

@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}}"

0

Se si desidera filtrare per processo, utilizzare findstr

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

0

Potresti voler avviare il monitoraggio delle risorse da PowerShell con:

PS C:\>resmon

Puoi sempre chiudere l'applicazione con Alt + F4 e questo dovrebbe riportare lo stato attivo sulla finestra di PowerShell.


1
OP vorrebbe usare sessioni remote PowerShell, quindi una risposta GUI non si adatta qui.
PL

0

Puoi provare htop-alternative per Windows - NTop

monitor di sistema simile a htop con Vi-emulation per Windows. Perché l'utilizzo di Task Manager non è abbastanza interessante.

inserisci qui la descrizione dell'immagine

NTop come in Windows NT-op o NukeTop. Qualunque cosa tu preferisca (quest'ultima ovviamente).

Opzioni della riga di comando :

  • -C Usa combinazione di colori monocromatici.
  • -h Visualizza le informazioni della guida.
  • -p PID, PID ... Mostra solo i PID indicati.
  • -s COLONNA Ordina per questa colonna.
  • -u USERNAME Visualizza solo i processi appartenenti a questo utente.
  • -v Versione stampabile.

Comandi interattivi:

  • Frecce Su e Giù, PgUp e PgDown, j e k Scorrere l'elenco dei processi.
  • CTRL + Frecce sinistra e destra Modifica la colonna di ordinamento del processo.
  • g Vai all'inizio dell'elenco dei processi.
  • G Andare in fondo all'elenco dei processi.
  • Spazio Contrassegna un processo selezionato.
  • U Deseleziona tutti i processi con tag.
  • K Uccidi tutti i processi con tag.
  • Ho Inverti l'ordinamento.
  • F Segui processo: se l'ordinamento fa spostare il processo attualmente selezionato nell'elenco, fare in modo che la barra di selezione lo segua. Lo spostamento manuale del cursore disattiva automaticamente questa funzione.
  • n Avanti nella ricerca.
  • N Precedente nella ricerca.

Comandi Vi :

  • : exec CMD Esegue il comando Windows indicato.
  • : kill PID (s) Kill tutti i processi dati.
  • : q ,: esci Esci da NTop.
  • / PATTERN,: search PATTERN Effettua una ricerca.
  • : ordina COLONNA Ordina l'elenco dei processi dopo la colonna specificata.
  • : albero Visualizza l'albero di processo.

I binari precompilati possono essere scaricati qui


1
Puoi approfondire come realizzare la soluzione con questo? dalla recensione Buona guida su come consigliare il software qui
fixer1234

0

Salvare quanto segue in un file chiamato mytop.ps1in una cartella nella PATHvariabile di ambiente. Quindi utilizzare uno dei seguenti da qualsiasi console di PowerShell:

  1. mytop - per utilizzare l'ordinamento predefinito nella colonna "Memoria" e mostrare le prime 30 righe.
  2. mytop CPU 50 - per ordinare in base alla colonna 'CPU' e mostrare le prime 50 righe.
  3. While(1) {$p = myTop Memory 50; cls; $p} - per aggiornarlo ogni secondo circa.

mytop.ps1 contenuto:

##################################################
#  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

Esempio di output:

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

Credito aggiuntivo a:

  1. rokumaru per https://stackoverflow.com/a/55698377/5060792
  2. LotPings per https://stackoverflow.com/a/55680398/5060792
  3. DBADon per https://stackoverflow.com/a/55697007/5060792


0

Usa il comando seguente ti darà i 10 migliori utilizzi della CPU e l'output verrà aggiornato ogni 5 secondi

while (1) {ps | Sort-Object -Property cpu -Descending | select -First 10; Write-Host "l'output verrà aggiornato in 5 sec. nn Maniglie NPM (K) PM (K) WS (K) ID CPU ProcessName"; sleep -Secondi 5}

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.