Как получить список все запущенных процессов и потоков


Содержание

Как получить список запущенных потоков в С#?

Я создаю динамические потоки в С#, и мне нужно получить статус этих запущенных потоков.

Как вы можете получить список запущенных потоков?

Создайте List и сохраните каждый новый поток в вашем первом цикле for.

Однако, если вам не нужен i , вы можете сделать второй цикл a foreach вместо for

В качестве побочного примечания, если ваша функция sendMessage не занимает очень много времени, вы должны иметь более легкий вес, а затем полный поток, используйте ThreadPool. QueueUserWorkItem или если он доступен вам, Task

В потоках

Я бы не стал явно создавать потоки самостоятельно.

Гораздо предпочтительнее использовать ThreadPool.QueueUserWorkItem , или если вы можете использовать .Net 4.0, вы получите гораздо более мощный Задача параллельной библиотеки, которая также позволяет вам использовать потоки ThreadPool гораздо более мощным способом ( Task.Factory.StartNew стоит посмотреть)

Что делать, если мы решим перейти к прямому созданию потоков?

Предположим, что ваш список [0].Count возвращает 1000 элементов. Предположим также, что вы выполняете это на high-end (на момент написания этой статьи) машине 16core. Непосредственный эффект заключается в том, что у нас есть 1000 потоков, конкурирующих за эти ограниченные ресурсы (16 ядер).

Чем больше количество задач и чем больше выполняется каждый из них, тем больше времени будет потрачено на переключение контекста. Кроме того, создание потоков является дорогостоящим, эти служебные данные, создающие каждый поток явно можно избежать, если используется подход к повторному использованию существующих потоков.

Таким образом, хотя первоначальным намерением многопоточности может быть увеличение скорости, как мы видим, это может иметь совершенно противоположный эффект.

Как мы преодолеем «чрезмерную» резьбу?

Пул потоков — это набор потоков, который может использоваться для выполнения ряда задач в фоновом режиме.

Как они работают:

Как только поток в пуле завершает свою задачу, он возвращается в очередь ожидающих потоков, где его можно повторно использовать. Это повторное использование позволяет приложениям избежать затрат на создание нового потока для каждой задачи.

Пулы потоков обычно имеют максимальное количество потоков. Если все потоки заняты, дополнительные задачи помещаются в очередь, пока они не могут обслуживаться по мере того, как потоки становятся доступными.

Таким образом, мы видим, что с помощью потоков пулов потоков мы более эффективны как

  • с точки зрения максимизации фактической работы . Поскольку мы не перегружаем процессоры потоками, меньше времени тратится на переключение между потоками и больше времени, фактически выполняющего код, который должен выполнять поток.
  • Более быстрый запуск потока : каждый поток потока доступен легко, а не ждет, пока не будет создан новый поток.
  • с точки зрения минимизации потребления памяти , threadpool будет ограничивать количество потоков в размере threadpool, зависящем от любых запросов, выходящих за пределы ограничения потока threadpool. (см. ThreadPool.GetMaxThreads ). Основная причина этого выбора дизайна, конечно, заключается в том, что мы не перенасыщаем ограниченное количество ядер со слишком большим количеством запросов на поток, сохраняя переход контекста на более низкие уровни.

Слишком много Теории, давайте проверить всю эту теорию!

Правильно, хорошо знать все это в теории, но давайте на практике и посмотрим, что номера говорят нам, с упрощенной грубой версией приложения, которая может дать нам грубое указание на разницу в порядках величины. Мы проведем сравнение между новой Thread, ThreadPool и параллельной библиотекой задач (TPL)

новая тема

ThreadPool.EnqueueUserWorkItem

Параллельная библиотека задач (TPL)

Итак, мы можем видеть, что:

Вышеприведенное хорошо сочетается с тем, что мы ожидали в теории. Высокая память для новой темы, а также более низкая общая производительность по сравнению с ThreadPool. ThreadPool и TPL имеют эквивалентную производительность, при этом TPL имеет немного более высокий объем памяти, чем чистый пул потоков, но, возможно, стоит заплатить за дополнительную гибкость. Задачи предоставляют (например, отмену, ожидая завершения запроса на выполнение задачи).

На этом этапе мы доказали, что использование потоков ThreadPool является предпочтительным вариантом с точки зрения скорости и памяти.

Тем не менее, мы не ответили на ваш вопрос. Как отслеживать состояние запущенных потоков.

Чтобы ответить на ваш вопрос

Учитывая полученные нами идеи, вот как я подхожу к нему:

Как получить список все запущенных процессов и потоков?

Перебор всех запущенных процессов на C++. Как получить список запущенных процессов? В этом примере мы определим, каким образом можно последовательно получить полный список всех процессов, запущенных в системе.

Функция CreateToolhelp32Snapshot возвращает Handle снимка процессов и динамических памятей, модулей и потоков, используемых процессами. Пример:

#include «stdafx.h»
#include «windows.h»
#include «iostream.h»
#include «tlhelp32.h»

int main(int argc, char* argv[])
<
HANDLE hSnap = NULL;
THREADENTRY32 te32;
hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hSnap!=NULL)
<
if (Thread32First(hSnap, &te32))
<
cout Автор: admin | 18.03.2008 | Камменты: нет

Получение списка процессов, выполняющихся в системе

ВВЕДЕНИЕ


Задача получения списка выполняющихся в системе процессов является одной из основных при выполнении мониторинга ресурсов как отдельного ПК, так и ЛВС в целом, поэтому для ее решения разработано значительное количество утилит, имеется встроенное системное средство – диспетчер задач.

Все перечисленные программные средства используют как функции Win32 API (Application Program Interface – прикладной программный интерфейс), так и функции еще одного базового интерфейса, называемого Native API (естественный API). Внешняя часть Native API пользовательского режима содержится в модуле ntdll.dll, «настоящий» интерфейс реализован в ntoskernel.exe – ядре операционной системы NT (NT operation system kernel). Функции Win32 API, как правило, обращаются к функциям Native API, отбрасывая часть полученной от них информации. Поэтому использование функций Native API позволяет получить, вообще говоря, более эффективное ПО.

К функциям Win32 API для получения информации о выполняющихся в системе процессах относятся функции CreateToolHelp32Snapshot(), Process32First(), Process32Next(), Thread32First(), Thread32Next(), Module32First(), Module32Next(), Heap32ListFirst(), Heap32ListNext() и некоторые другие. Самая известная из функций Native API для доступа к содержимому многих важных внутренних структур операционной системы, таких как списки процессов, потоков, дескрипторов, драйверов и т.п., – функция ntQuerySystemInformation () – вывод счетчика производительности.

Студенты заочной формы обучения выполняют контрольную работу. Для этого каждый студент получает у ведущего преподавателя карточку-задание, изображенную на рисунке 1.

Вариант №__ Вывести на форму список процессов с указанием приоритета. Список должен обновляться при нажатии на кнопку «Обновить». Для каждого прикладного процесса вывести время его старта и время работы в режиме пользователя. Предусмотреть возможность завершения выбранного из списка прикладного процесса по кнопке «Завершить». На форму выводить следующие статистические сведения: · общее количество процессов; · общее количество потоков; · имя процесса, запущенного последним.
Задание получил: ____________ Дата: _________ Задание выдал: ____________ Дата: __________

Рис. 1. Карточка-задание на контрольную работу для студента

БАЗОВЫЕ ФУНКЦИИ

Цель работы – практическое знакомство с методикой использования базовых функций для получения информации о процессах, потоках, модулях и кучах ОС Windows XP.

Илон Маск рекомендует:  Оптимизация javascript скриптов

Краткие теоретические сведения

Получение списка процессов, выполняющихся в системе

1.1.1 Использование функций CreateToolHelp32Snapshot () и Process32xxxx()

для получения списка имен процессов

Первый этап получения информации о выполняющихся в системе процессах –получение снимка (snapshot) системы, который содержит информацию о состоянии системы в момент выполнения снимка.

Снимок создается с помощью функции CreateToolHelp32Snapshot(dwFlags, th32ProcessID), первый аргумент определяет, какая информация будет записана в снимок. Возможные значения dwFlags приведены в таблице 1.

Возможные значения dwFlags

Флаг — dwFlags Описание
TH32CS_SnapHEAPLIST В снимок включается список куч, принадлежащих указанному процессу
TH32CS_SnapPROCESS В снимок включается список процессов, присутствующих в системе
TH32CS_SnapTHREAD В снимок включается список потоков
TH32CS_SnapMODULE В снимок включается список модулей, принадлежащих указанному процессу
TH32CS_SnapALL В снимок включается список куч, процессов, потоков и модулей

Второй аргумент определяет процесс, информация о котором необходима (если требуется список куч и модулей). В остальных случаях он игнорируется.

Второй этап – извлечение из снимка списка процессов. Для выполнения этой операции служат функции:

Process32First ( hSnapshot, LPProcessEntry32);

Process32Next ( hSnapshot, LPProcessEntry32).

Первый аргумент – хэндл созданного снимка (возвращает функция CreateToolHelp32Snapshot).

Второй аргумент – структура, содержащая 10 полей:

1. Первое поле – dwSize – размер структуры в байтах. Это единственное поле, которое должно быть заполнено до вызова функцииProcess32First. Заполнить его можно, используя выражение sizeof(PROCESSENTRY32).

2. Второе поле – cntUsage – содержит число ссылок на процесс, то есть число потоков, которые в настоящий момент используют какие-либо данные процесса.

3. Третье поле – th32ProcessID – является идентификатором процесса.

4. Четвертое поле – th32DefaultHeapID – не используется, и всегда устанавливается в ноль.

5. Пятое поле – th32ModuleID – не используется, и всегда устанавливается в ноль.

6. Шестое поле – cntThreads – определяет число потоков, принадлежащих процессу.

7. Седьмое поле – th32ParentProcessID – является идентификатором родительского по отношению к текущему процесса.

8. Восьмое поле – pcPriClassBase – содержит базовый приоритет процесса.

9. Девятое поле – dwFlags – не используется, и всегда устанавливается в ноль.

10. Десятое поле – szExeFile – содержит имя файла, создавшего процесс.

Для того, чтобы получить информацию о первом процессе в снимке, необходимо вызвать функцию Process32First. В случае успешного завершения функция возвращает TRUE. Для того, чтобы просмотреть все оставшиеся процессы, нужно вызывать функцию Process32Next до тех пор, пока она не возвратит FALSE.

В список используемых модулей – uses – необходимо добавить модуль TlHelp32

Пример 1. Получить список имен выполняющихся в системе процессов, используя рассмотренные выше функции.

На форме размещены компоненты ListBox, Label и Button, обработчик события OnClick имеет вид:

Pr_names: array [0..80] of string;

// получение снимка состояния системы

// выделение из снимка имени первого процесса


// получение имен других процесса

while Process32Next(SH,PPE) do

// вывод списка имен выполняющихся процессов

for I:=0 to Num do Listbox1.Items.Add(Pr_Names[I]);

// освобождение ресурса – снимка состояния системы

Результат выполнения примера 1 показан на рис. 2.

Рис. 2. Список выполняющихся процессов

1.1.2 Использование функций CreateToolHelp32Snapshot () и Thread32xxxx()

для получения сведений о приоритетах потоков процессов

Для получения сведений о приоритетах потоков необходимо извлечь из снимка состояния системы с помощью функций Thread32First() и Thtead32Next () значения соответствующих полей.

Обращение к функциям имеет вид:

Thread32First (hSnapshot, LPTHREADEntry32)

Thtead32Next (hSnapshot, LPTHREADEntry32).

Первый аргумент – хэндл созданного снимка (возвращает функция CreateToolHelp32Snapshot).

Второй аргумент – структура, содержащая 7 полей:

1. Первое поле – dwSize – размер структуры в байтах. Это единственное поле, которое должно быть заполнено до вызова функцииThread32First. Заполнить его можно, используя выражение sizeof(ThreadEntry32).

2. ПолеcntUsageth–не используется и всегда устанавливается в ноль.

3. Поле32ThreadID– не используется и всегда устанавливается в ноль.

4. Поле – th32OwnerProcessID – содержит идентификатор родительского процесса.

5. Поле – tpBasePri – содержит текущий приоритет потока.

6. Поле – tpDeltaPri – содержит разность между текущим уровнем приоритета потока и базовым уровнем, то есть тем, который присваивается при создании потока.

7. Поле – dwFlags– не используется и всегда устанавливается в ноль.

Пример 2. Получить список выполняющихся в системе потоков, используя рассмотренные выше функции. Вывести содержимое полей 2 и 3 структуры THREADEntry32.

На форме размещены компоненты ListView, Label и Button, обработчик события OnClick имеет вид:

Команда Tasklist в CMD: сохраняем список запущенных процессов Windows 10 / 8 / 7 в текстовый файл

Известно, что штатный Диспетчер задач Windows выводит информативный список активных процессов и имеет опции «Снять задачу» и «Запустить новую задачу«. Однако вы не найдете в нем типовых функций «Сохранить как» или «Печать». Что же делать, если возникла необходимость экспортировать список запущенных процессов и служб в текстовый файл (распечатать)?

Один из способов – воспользоваться спецутилитами Process Explorer от Марка Руссиновича или TaskSchedulerView от Нира Софера, известными любому сисадмину. Но лучше не «сорить» в системе и обойтись без стороннего программного обеспечения. Все, что для этого нужно – знать пару команд, выполняемых в командной строке.

Как распечатать список запущенных процессов Windows

  • Итак, откройте меню «Пуск«, введите в поле поиска cmd.exe и нажмите «Enter«.
  • Наберите в консоли tasklist и повторно задействуйте клавишу «Enter» (скриншот выше). Сиюсекундно отобразятся все приложения и службы с кодом процесса (P >
  • Команда Tasklist имеет множество параметров и фильтров, позволяющих сортировать выводимую информацию. Чтобы получить подробную справку по сабжу, введите «tasklist /?» (без кавычек). А для завершения нескольких зависших процессов используется команда taskkill, чего нельзя сделать силами Диспетчера задач.
  • Ознакомившись со списком текущих процессов, наберите tasklist > D:processes.txt→ «Enter«, и в корне диска D:\ появится соответствующий текстовый файл.
  • Посетите несистемный логический диск и откройте файл processes.txt. Если вместо осмысленного текста в нем выведены непонятные символы («кракозябры»), измените кодировку через консольное chcp 1251 → «Enter» (скриншот).
  • Вновь скомандуйте tasklist > D:processes.txt и проверьте перезаписанный processes.txt – «кракозяблики» должны исчезнуть (скриншот ниже).
  • Осталось только открыть в панели блокнота «Файл» → «Печать» (комбинация клавиш «Ctrl +P«) и перенести список висящих в ОЗУ приложений и служб на бумагу.
  • Тот же результат достижим с помощью инструмента для системных администраторов PowerShell. Запомните всего два командлета (так называются команды для PowerShell):


get-process | out-file D:process.txt – вывод списка процессов в файл в корне диска D:\,

get-process | out-printer – вывод списка активных процессов Windows 10/8/7 на принтер.

Дмитрий dmitry_spb Евдокимов

Записки программиста

Получаем список запущенных процессов на Windows API

11 декабря 2013

А тем временем я все продолжаю ностальгировать по сишечке и WinAPI. Сегодня совместными усилиями мы вспомним, как на WinAPI получить список запущенных процессов, а также динамических библиотек, используемых этими процессами.

Для этого нам понадобятся следующие процедуры и структуры.

CreateToolhelp32Snapshot создает снапшот запущенных процессов, модулей, нитей и так далее. Аргумент dwFlags определяет, снапшот чего именно мы хотим получить. Некоторые возможные значения — TH32CS_SNAPPROCESS, TH32CS_SNAPMODULE, TH32CS_SNAPTHREAD. Параметр dwProcessId задает идентификатор процесса, для которого создается снапшот. Может быть ненужным и устанавливаться в ноль в зависимости от dwFlags. В случае успеха процедура возвращает хэндл снапшота, который должен быть потом закрыт с помощью уже знакомой нам процедуры CloseHandle. В случае ошибки возвращается значение INVALID_HANDLE_VALUE, а подробности поможет узнать GetLastError.

Process32First принимает хэндл, полученный от CreateToolhelp32Snapshot, вызванной с dwFlags = TH32CS_SNAPPROCESS, а также указатель на структуру PROCESSENTRY32. Перед вызовом процедуры поле dwSize этой структуры должно быть установлено в sizeof ( PROCESSENTRY32 ) . В случае успеха возвращается TRUE, а в peProcessEntry записывается информация о первом процессе. В случае ошибки возвращается FALSE, а подробности поможет узнать GetLastError.

Процедура Process32Next работает полностью аналогично Process32First, но служит для получения второго и последующих процессов.

Еще мы воспользуемся процедурами Module32First и Module32Next, а также структурой MODULEENTRY32. Семантика у этих процедур полностью аналогична Process32First и Process32Next, только служат они для перечисления модулей в заданном процессе (CreateToolhelp32Snapshot с параметром dwFlags, равным TH32CS_SNAPMODULE).

Проще всего понять, как все это работает, посмотрев на пример кода:

VO >( HANDLE CONST hStdOut , DWORD CONST dwProcess >) <
MODULEENTRY32 meModuleEntry ;
TCHAR szBuff [ 1024 ] ;
DWORD dwTemp ;
HANDLE CONST hSnapshot = CreateToolhelp32Snapshot (
TH32CS_SNAPMODULE , dwProcess >) ;
if ( INVAL >== hSnapshot ) <
return ;
>

meModuleEntry. dwSize = sizeof ( MODULEENTRY32 ) ;
Module32First ( hSnapshot , & meModuleEntry ) ;
do <
wsprintf ( szBuff , L » ba: %08X, bs: %08X, %s \r \n » ,
meModuleEntry. modBaseAddr , meModuleEntry. modBaseSize ,
meModuleEntry. szModule ) ;
WriteConsole ( hStdOut , szBuff , lstrlen ( szBuff ) , & dwTemp , NULL ) ;
> while ( Module32Next ( hSnapshot , & meModuleEntry ) ) ;

VO >( HANDLE CONST hStdOut ) <
PROCESSENTRY32 peProcessEntry ;
TCHAR szBuff [ 1024 ] ;
DWORD dwTemp ;
HANDLE CONST hSnapshot = CreateToolhelp32Snapshot (
TH32CS_SNAPPROCESS , 0 ) ;
if ( INVAL >== hSnapshot ) <
return ;
>

peProcessEntry. dwSize = sizeof ( PROCESSENTRY32 ) ;
Process32First ( hSnapshot , & peProcessEntry ) ;
do <
wsprintf ( szBuff , L «=== %08X %s === \r \n » ,
peProcessEntry. th32ProcessID , peProcessEntry. szExeFile ) ;
WriteConsole ( hStdOut , szBuff , lstrlen ( szBuff ) , & dwTemp , NULL ) ;
PrintModuleList ( hStdOut , peProcessEntry. th32ProcessID ) ;
> while ( Process32Next ( hSnapshot , & peProcessEntry ) ) ;

INT main ( ) <
HANDLE CONST hStdOut = GetStdHandle ( STD_OUTPUT_HANDLE ) ;
PrintProcessList ( hStdOut ) ;
ExitProcess ( 0 ) ;
>

Сначала мы получаем список всех процессов в системе, а затем для каждого процесса выводим информацию о нем, а также список модулей. На мой взгляд, код этот очень простой и не нуждается в дополнительных пояснениях.

Как обычно, вы можете собрать эту программу не только под Visual Studio, но и при помощи MinGW, а затем запустить под Wine. В качестве домашнего задания можете изменить программу так, чтобы она также выводила информацию о нитях, используемых в каждом из запущенных процессов. Для этого вам понадобятся процедуры Thread32First, Thread32Next, а также структура THREADENTRY32.

Если у вас есть вопросы или дополнения, я буду рад ознакомиться с ними в комментариях.

Как посмотреть список список запущенных процессов из командной строки и как их завершить.

Бывают ситуации, когда нужно посмотреть/завершить запущенные процессы из командной строки. Это бывает нужно если вы управляете компьютером удаленно из командной строки, либо если компьютер сильно загружен, и очень много времени уходит на запуск диспетчера задач. Еще бывает такое, что через диспетчер задач процесс не завершается. В этих случаях вам может помочь способ просмотра и завершения задач из командной строки, о чем я и расскажу ниже.
Для того что бы посмотреть запущенные процессы, существует утилита командной строки – tasklist, пример результата ее выполнения ниже на скриншоте. Из нее нам нужно запомнить имя процесса или PID, если несколько процессов запущенны с одним именем.

Для того что бы завершить задачу, можно воспользоваться утилитой taskkill, я его обычно использую с ключами /f /pid или /f /im, где после ключ /pid нужно указать ID процесса, после /im его имя
Например завершим все запущенные процессы google chrome, для этого нужно набрать команду:

Что бы завершить один процесс internet explorer нужно набрать:

Поделитесь статьей с друзьями в соц. сетях, возможно, она будет им полезна.

Список процессов Linux

На сайте уже есть несколько статей про процессы Linux, в которых подробно описано как ими управлять или как завершить один или группу процессов, но это еще не все. Чтобы правильно управлять процессами и ориентироваться в них вам нужно научиться анализировать список процессов Linux, понимать что значит каждый пункт и зачем он нужен.

В этой статье мы подробно рассмотрим как посмотреть список процессов, разберем какими бывают процессы, почему так происходит и что с этим делать.

Что такое процесс?

Процесс Linux — это экземпляр программы, запущенный в памяти. Все процессы можно разделить на обычные и фоновые. Более подробно об этом написано в статье управление процессами Linux. Linux — это многопользовательская система, каждый пользователь может запускать одни и те же программы, и даже один пользователь может захотеть запустить несколько экземпляров одной программы, поэтому ядру нужно как-то идентифицировать такие однотипные процессы. Для этого каждому процессу присваивается PID (Proccess Identificator).

Каждый из процессов может находиться в одном из таких состояний:

  • Запуск — процесс либо уже работает, либо готов к работе и ждет, когда ему будет дано процессорное время;
  • Ожидание — процессы в этом состоянии ожидают какого-либо события или освобождения системного ресурса. Ядро делит такие процессы на два типа — те, которые ожидают освобождения аппаратных средств и приостановление с помощью сигнала;
  • Остановлено — обычно, в этом состоянии находятся процессы, которые были остановлены с помощью сигнала;
  • Зомби — это мертвые процессы, они были остановлены и больше не выполняются, но для них есть запись в таблице процессов, возможно, из-за того, что у процесса остались дочерние процессы.

А теперь давайте перейдем ближе к практике и поговорим о том, как узнать запущенные процессы linux.

Список процессов Linux

Самые популярные команды для решения этой задачи — это ps, top и htop. Последние две команды мы уже рассматривали в предыдущих статьях, собственно, они интерактивные и с ними у вас не возникнет проблем. Сейчас же хотелось бы остановиться более детально на ps. Сначала рассмотрим общий синтаксис команды, здесь все очень просто:

$ ps опции

$ ps опции | grep параметр


Во втором варианте мы используем утилиту grep для того, чтобы отобрать нужные нам процессы по определенному критерию. Теперь рассмотрим опции утилиты. Они делятся на два типа — те, которые идут с дефисом Unix и те, которые используются без дефиса — BSD. Лучше пользоваться только опциями Unix, но мы рассмотрим и одни и другие. Заметьте, что при использовании опций BSD, вывод утилиты будет организован в BSD стиле.

  • -A, (a) — выбрать все процессы;
  • -a — выбрать все процессы, кроме фоновых;
  • -d, (g) — выбрать все процессы, даже фоновые, кроме процессов сессий;
  • -N — выбрать все процессы кроме указанных;
  • — выбирать процессы по имени команды;
  • -G — выбрать процессы по ID группы;
  • -p, (p) — выбрать процессы PID;
  • —ppid — выбрать процессы по PID родительского процесса;
  • -s — выбрать процессы по ID сессии;
  • -t, (t) — выбрать процессы по tty;
  • -u, (U) — выбрать процессы пользователя.
  • — отображать информацию планировщика;
  • -f — вывести максимум доступных данных, например, количество потоков;
  • -j, (j) — вывести процессы в стиле Jobs, минимум информации;
  • -M, (Z) — добавить информацию о безопасности;
  • -o, (o) — позволяет определить свой формат вывода;
  • —sort, (k) — выполнять сортировку по указанной колонке;
  • -L, (H)— отображать потоки процессов в колонках LWP и NLWP;
  • -m, (m) — вывести потоки после процесса;
  • -V, (V) — вывести информацию о версии;
  • -H — отображать дерево процессов linux;

Теперь, когда вы знаете синтаксис и опции, можно перейти ближе к практике и посмотреть запущенные процессы в Linux. Чтобы просто посмотреть процессы в linux в текущей оболочке используйте команду без параметров:

Все процессы, кроме лидеров групп, в том же режиме отображения:

Все процессы, включая фоновые и лидеры групп:

Чтобы вывести больше информации о процессах используйте опцию -f:

При использовании опции -f команда выдает такие колонки:

  • UID — пользователь, от имени которого запущен процесс;
  • PID — идентификатор процесса;
  • PPID — идентификатор родительского процесса;
  • C — процент времени CPU, используемого процессом;
  • STIME — время запуска процесса;
  • TTY — терминал, из которого запущен процесс;
  • TIME — общее время процессора, затраченное на выполнение процессора;
  • CMD— команда запуска процессора;
  • LWP — показывает потоки процессора;
  • PRI — приоритет процесса.

Например, также можно вывести подробную информацию обо всех процессах:

Больше информации можно получить, использовав опцию -F:

Если вы хотите получить еще больше информации, используйте вместо -f опцию -l:

Дальше мы можем отобрать все процессы, запущенные от имени определенного пользователя:

С помощью опции -H можно отобразить дерево процессов:

Если вас интересует информация только об определенном процессе, то вы можете использовать опцию -p и указать pid процесса linux:

Через запятую можно указать несколько PID:

Опция позволяет фильтровать процессы по имени, например, выберем только процессы chrome:

Дальше можно использовать опцию -L чтобы отобразить информацию о процессах:

Очень интересно то, с помощью опции -o можно настроить форматирование вывода, например, вы можете вывести только pid процесса linux и команду:

Вы можете выбрать такие колонки для отображения: pcpu, pmem, args, comm, cputime, pid, gid, lwp, rss, start, user,vsize,priority. Для удобства просмотра можно отсортировать вывод программы по нужной колонке, например, просмотр процессов linux, которые используют больше всего памяти:

Или по проценту загрузки cpu:

ps -FA —sort pcpu

Еще одна опция — M, которая позволяет вывести информацию про права безопасности и флаги SELinux для процессов:

Общее количество запущенных процессов Linux можно узнать командой:

Мы рассмотрели все основные возможности утилиты ps. Дальше вы можете поэкспериментировать с ее параметрами и опциями чтобы найти нужные комбинации, также можно попытаться применить опции BSD.

Выводы

Команда ps может быть очень полезной если система перегружена и вам необходимо срочно узнать запущенные процессы linux чтобы освободить память или ресурсы процессора. Интерактивные средства не всегда могут помочь, потому что они потребляют слишком много ресурсов. С другой стороны ps дает большую гибкость поскольку утилита имеет множество опций и параметров. Во всяком случае теперь вы знаете как вывести список процессов linux. Если остались вопросы, спрашивайте в комментариях!

Как получить список всех запущенных процессов и потоков

Written on 25 Августа 2007 .

Для Windows 9x:
используйте CreateToolhelp32Snapsot/ Process32First(Process32Next)/ Thread32First(Thread32Next).

Для WinNT:
NTQuerySystemInformation. А можно так: получаете список окон в системе (каким угодно способом, если нужны только процессы — можно ограничиться top-level), далее — GetWindowTreadProcessID — получаете ID процесса (и нити). OpenProcess — дает handle процесса.

При копировании материалов наличие активной индексируемой ссылки на сайт обязательно.

Изучение процессов

Помимо полного списка всех выполняющихся на конкретной машине процессов, статический метод Process.GetProcessById() позволяет получать информацию и по конкретному объекту Process за счет указания ассоциируемого с ним идентификатора (PID). В случае запроса несуществующего PID генерируется исключение ArgumentException.

Набор потоков представляется в виде строго типизованной коллекции ProcessThreadCollection, в которой содержится определенное количество отдельных объектов ProcessThread. Свойство Threads в System.Diagnostics.Process предоставляет доступ к классу ProcessThreadCollection, некоторые наиболее интересные члены которого перечислены ниже:

Позволяет получить информацию о текущем приоритете потока


Позволяет получить уникальный идентификатор потока

Позволяет указать предпочитаемый процессор для выполнения данного потока

Позволяет получить или задать уровень приоритета потока

Позволяет указать процессоры, на которых может выполняться соответствующий поток

Позволяет узнать, по какому адресу в памяти операционная система вызывала функцию, приведшую к запуску данного потока

Позволяет узнать, когда операционная система запустила поток

Позволяет узнать текущее состояние данного потока

Позволяет узнать, сколько всего времени данный поток использовал процессор

Позволяет узнать причину, по которой поток находится в состоянии ожидания

Прежде чем двигаться дальше, необходимо четко уяснить, что тип ProcessThread не является сущностью, применяемой для создания, приостановки и уничтожения потоков в .NET. Он скорее представляет собой средство, позволяющее получать диагностическую информацию по активным потокам Windows внутри выполняющегося процесса.

Теперь давайте посмотрим, как реализовать проход по загруженным модулям, которые обслуживаются в рамках конкретного процесса. При обсуждении процессов модуль — это общий термин, используемый для описания заданной сборки *.dll (или *.ехе), которая обслуживается в определенном процессе. При получении доступа к ProcessModuleCollection через свойство Process.Modules можно извлечь список всех модулей, которые обслуживаются внутри процесса: .NET, СОМ и традиционных основанных на С библиотек.

И, наконец, последними членами класса System.Diagnostics.Process, которые осталось рассмотреть, являются методы Start() и Kill(). Эти методы позволяют, соответственно, программно запускать и завершать процесс. Метод Start() может принимать тип System.Diagnostics.ProcessStartInfо и предоставлять дополнительные фрагменты информации относительно запуска определенного процесса.

Давайте рассмотрим пример глобального изучения процессов:

Как я могу получить список всех процессов, запущенных в Windows?

December 2020

48k раз

Я хотел бы найти путь к петле через все активные процессы и сделать диагностику проверки на них (использовании Mem, процессорное время и т.д.) своего родом подобного менеджеру задач.

Проблема разбивается на две части:

  1. Нахождение всех процессов
  2. Поиск диагностики атрибутов о них

Я не уверен, что даже в каком пространстве имен идти искать о нем. Любая помощь / советы / ссылка признательна.

7 ответы

Какую операционную систему ты используешь? Я беру его из C # тега, что это окно?

Если да, то проверить WMI, в частности , класс Win32_Process. Вот ссылка MSDN: http://msdn.microsoft.com/en-us/library/aa394372(VS.85).aspx

А также несколько сценариев использования здесь (например, получение списка процессов): http://msdn.microsoft.com/en-us/library/aa394599(VS.85).aspx

Нахождение всех процессов довольно легко actualy:

JaredPar уже указывал на Process класс, так что я просто добавить, что вы должны знать, что класс делает снимок процесса информации при создании экземпляра. Это не живой вид. Для того, чтобы обновить его , вы должны вызвать Refresh() на экземпляре.

Кроме того, имейте в виду, что этот процесс может закрыть, пока вы осматривая его, так что будьте готовы ловить исключения и обрабатывать их соответствующим образом.

И , наконец , если вы звоните Process.GetProcesses() вы также получите процессы псевдо «холостой ход» и «система». IIRC они имеют конкретные идентификаторы процессов , так что вы можете легко фильтровать их.

Ну вы можете сделать это в PowerShell

1.Finding всех процессов

2.Finding диагностики атрибутов о них

Приведенный выше код будет возвращать все процессы с более чем 200 ручек, вы можете указать диагностические признаки таким образом легко.

Это, как я предпочитаю, чтобы получить доступ к процессам:

здесь процесс arrray содержит все количество процессов настоящего в него.

Поиск всех процессов

Вы можете сделать это с помощью класса Process

Запуск диагностики

Можете ли вы дать нам больше информации здесь? Пока не ясно, что вы хотите сделать.

Класс Process предоставляет немного информации, хотя это может помочь вам. Можно запросить этот класс для

  • Все темы
  • Главное окно ручки
  • Все загруженные модули
  • Различные диагностические данные о памяти (выгружаемого, Virtual, Working Set, и т.д . )
  • Базовая информация процесса (идентификатор, имя, место на диске)

РЕДАКТИРОВАТЬ

OP отметил, что они хотят получить информацию о памяти и процессора. Эти свойства легко доступны на классе Process (возвращенный GetProcesses ()). Ниже на странице MSDN, в котором перечислены все поддерживаемые свойства. Существуют различные памяти и процессора те, которые доступны будут в отелях.

Илон Маск рекомендует:  Лучшие браузеры. Обзор самых популярных и быстрых браузеров
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL