Process.kill метод

Подробная информация о процессе

Для каждого процесса создается каталог по пути /proc/<PID>, в котором создаются папки и файлы с описанием процесса.

Примеры использования /proc/<PID>

Подробный вывод статуса:

cat /proc/<PID>/status

Адрес в ячейках оперативной памяти, которые занял процесс:

cat /proc/<PID>/syscall

Команда, которой был запущен процесс:

cat /proc/<PID>/cmdline

Символьная ссылка на рабочий каталог процесса:

ll /proc/<PID>/cwd

Символьная ссылка на исполняемый файл, запустивший процесс:

ll /proc/<PID>/exe

Увидеть ссылки на дескрипторы открытых файлов, которые затрагивает процесс:

ll /proc/<PID>/fd/

Подробное описание на сайте man7.org.

Как использовать команду killall

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

Например, откройте небольшую программу, такую ​​как средство просмотра изображений. Теперь откройте другую копию одного и того же средства просмотра изображений. Для моего примера я выбрал Xviewer, который является клоном Eye Of Gnome.

Теперь откройте терминал и введите следующую команду:

Например, чтобы убить все экземпляры типа Xviewer, выполните следующие действия:

Оба экземпляра программы, которую вы решили убить, теперь будут закрыты.

13 ответов

148

Лучший ответ

Используйте команду

используется как использует как свои процессы.

Он покажет список процессов с номером порта и идентификатором процесса

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

подразумевает, что процесс будет убит принудительно.

20 июль 2012, в 18:10
Поделиться

423

Этот будет печатать вам PID процесса, связанного с этим портом.

И этот убьет этот процесс.

Работает только с Linux. Более универсальным является использование (или 6 для IPv6).

21 июль 2012, в 23:17
Поделиться

186

Чтобы перечислить любой процесс, прослушивающий порт 8080:

Чтобы убить любой процесс, прослушивающий порт 8080:

или более яростно:

15 сен. 2015, в 20:09
Поделиться

82

Вы можете использовать команду lsof.
Номер порта, например, 8090

Эта команда возвращает список открытых процессов на этом порту.

Что-то вроде…

Чтобы освободить порт, запустите процесс, используя его (идентификатор процесса — 75782)…

Этот работал у меня.
вот ссылка с исходного сообщения: ссылка

11 фев. 2015, в 11:16
Поделиться

44

Я бы добавил этот однострочный слой только для LISTEN на конкретный порт:

22 янв. 2017, в 15:17
Поделиться

34

Это выводит на печать идентификаторы процессов всего, что выполняется на :

Он также печатает некоторые вещи для stderr, поэтому:

Затем мы можем предоставить эти идентификаторы процессов команде :

Вы также можете поместить это в функцию, если вы сделаете это много:

27 сен. 2013, в 22:36
Поделиться

24

Знать pid службы, запущенной на определенном порту:

вы получите описание этого процесса. Теперь используйте kill или kill -9 pid. Легко убит.

например

Сейчас:

Не забудьте запустить все команды как

12 авг. 2014, в 09:01
Поделиться

12

попробуйте это,

26 июнь 2015, в 12:02
Поделиться

10

  • Эта команда перечисляет информацию о запуске процесса на порту 8000

  • Эта команда убивает процесс

16 дек. 2015, в 10:34
Поделиться

6

Linux. Вы можете использовать эту команду, если знаете порт:

AIX:

Затем вы берете первый столбец (пример: f100050000b05bb8) и выполняете следующую команду:

убить процесс.

12 авг. 2014, в 08:52
Поделиться

2

, эти команды также убивают процесс, который прослушивает порт 8080 с помощью TCP-соединения

22 май 2017, в 07:25
Поделиться

чтобы опираться на то, что @veer7 сказал:

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

Используйте ‘ps’ и номер процесса, о котором сообщается netstat

12 окт. 2017, в 02:15
Поделиться

-4

В Windows это будет , и мы получим следующее сообщение

МЫ можем убить PID, используя

28 сен. 2016, в 07:29
Поделиться

Ещё вопросы

  • 997Перебирая содержимое файла в Bash
  • 656Как навсегда установить $ PATH в Linux / Unix?
  • 448Как запустить сценарий оболочки на консоли Unix или Mac?
  • 442Как мне заставить CURL не показывать индикатор выполнения?
  • 277Прерывание сценария оболочки, если какая-либо команда возвращает ненулевое значение?
  • 271Как преобразовать новую строку DOS / Windows (CRLF) в новую строку Unix (LF) в сценарии Bash?
  • 178В чем разница между «#! / Usr / bin / env bash» и «#! / Usr / bin / bash»?
  • 102Заставить программу работать медленно
  • 183Как заставить дочерний процесс умереть после родительского выхода?
  • 172C fopen vs open

Locating the process to kill

In order to kill a process, you should first locate the details of the process. You can do this through three commands — , ,  and . Depending upon the situation, you can use one of these commands for this purpose.

As we will see later in this article, you can kill a process by its name or its process ID (PID). The PID is a number that uniquely identifies a process. Killing by the process ID is useful when you want to kill only a specific process. On the other hand, killing by the process name is useful when you want to kill all running instances of a particular program.

Locating the process with the top command

We will first look at the  command. Fire up the top command by typing:

top

You will get an interactive interface, as shown below. You can browse through this list to find the name or the PID of the process you want to kill.

To browse through this list, you can use the up/down keys. Additionally, the top command also has ways to filter processes by CPU usage, user and process names, which you can read about in this guide.

The leftmost column contains the PID of the process, and the right side contains the program name. As an example, in the above screenshot we have the  process running with a process ID of 263.

Locating the process with ps and grep commands

Another way to get a list of process is by running:

ps aux

In the above command, we have used the flags  which have the following meanings:

  • : Show processes for all users
  • : Display the user who is using the process
  • : Show all processes. (Without this,  won’t show processes running in a GUI environment.)

The output of the command is similar to that of . The PID is available in second column from the left, and the process name is available on the rightmost column.

The advantage of using  is that you can easily filter this list with the  command. For example, to find a process associated with the term “vnstat”, you can use:

ps aux | grep -i vnstat

Here, we got two results — the  process, as well as the  process. Since we were searching for all instances of the term “vnstat”, and we were also running  with “vnstat” as its argument, we got   as well in the results.

Thus, even when there are no “vnstat” related processes running, we would get one entry showing the process:

So, even though we got a result, there are no processes that are of interest to us.

Finding the PID with pidof and pgrep

The  and / combination allows us to search for processes. On the other hand, if you know the exact name of a process, you can use  to find its PID.

Using  is pretty straightforward. To get the PIDs of a process with the exact name of “nginx”, use:

pidof nginx

If there are processes with the exact name of “nginx”, you will get a list of PIDs, as shown below. If there are none, you will get nothing as the output.

If you don’t know the full name, you can use  instead of . As an example, to search for all processes that contain “ngin” somewhere in their name, run:

pgrep ngin

This will match processes with the exact name of “nginx”, as well as any other process that matches the same criteria. For our system, notice that we get all the PIDs that belonged to “nginx” in the above screenshot.

The  and commands give you far less information. As we shall see in the next section, there are some circumstances in which you can’t kill a process. The output of  and  contain additional information that help you determine if you can really kill a process.

4 ответа

22

У вас нет зомби. не будет проблем с зомби. Если не убивает программу , это означает, что программа выполняет некоторую операцию прерывания ввода-вывода. Обычно это указывает на одну из трех вещей:

  • сетевая файловая система, которая не отвечает;
  • ошибка ядра;
  • аппаратная ошибка.

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

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

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

6

Другие ответы предполагают, что это зомби-процессы. Процесс зомби — это процесс, который завершил работу, но все еще находится в таблице процессов, если родитель хочет знать статус выхода. Это нормально, а автоматически очистят процессы зомби, которые будут назначены ему.

Процессы зомби никогда не должны заставлять что-либо висеть, так что это звучит так, что это может не быть вашей проблемой. Если это системный вызов или водитель висит, то процесс может находиться в состоянии бесперебойного питания. Здесь есть хорошее объяснение здесь .

1

Найти процессы зомби в Linux:

Сначала вы можете попробовать отправить сигнал SIGCHLD в родительский процесс zombie с помощью команды kill

Обратите внимание, что приведенная выше команда дает вам PPID (PID родительского процесса) каждого зомби. В нашем примере PPID зомби составляет 250

Если процесс зомби все еще не исчезнет, ​​вы можете убить родительский процесс (например, 250) зомби.

Как только его родительский процесс будет убит, зомби будет принят процессом init, который является родителем всех процессов в Linux. Процесс init периодически вызывает wait () для получения любого процесса зомби.

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

Процессы в Linux

Вам будет интересно:Чистка ПК от мусора: программы, инструкция и рекомендации

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

Все процессы, работающие в Linux, имеют такие атрибуты:

PID — уникальный для каждого процесса идентификатор.
PPID — идентификатор родительского процесса.
Идентификатор пользователя, запустившего процесс.
Приоритет.
Состояние процесса.

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

  • «Выполняется». Для обозначения этого состояния используется буква R.
  • Процесс, который запустил системную операцию, например ввод или вывод данных, и ждет когда завершится ее выполнение, называется «Ожидание». Обозначается буквой S.
  • Процесс, который остановлен пользователем или ОС Linux, находится в состоянии «Остановлен». Это состояние обозначается символом Т.
  • «Зомби» — процессы, которые больше не выполняются, но потребляют ресурсы операционной системы. Обозначаются буквой Z.
  • Непрерывный процесс нельзя завершить, пока не закончится операция прямого доступа в память. Обозначается процесс символом D.

What Is the kill System Call?

On Linux, a system call is an interface to access kernel functionality. Low-level tasks can be performed by asking the kernel to do them for us.

To end processes, we can use the kill system call. It takes two arguments: the process ID and the signal to send when killing the process.

A signal indicates . It’s composed of a name and a related number. The process will respond differently depending on the signal it receives. There are many signals we could send a process we’re killing, but let’s see a few that are the most popular.

We could send signal SIGTERM (15) or SIGINT (2) to ask the process to shut down gracefully. The process can ignore this request.

We could send SIGKILL (9) or SIGSTOP (19), which cannot be ignored. SIGKILL forces the process to terminate, while SIGSTOP pauses it.

In this tutorial, we’ll focus on terminating processes, but thanks to signals, we could use the kill call more broadly. For instance, we could pause and resume processes, or cause them to reload their configuration.

Let’s now see how commands use this system call.

How to kill process in Linux from the command line

The syntax is:

kill -signal PID
kill -15 PID
kill -9 PID
kill -SIGTERM PID
kill options -SIGTERM PID

What Linux or Unix permissions do I need to kill a process?

Rules are simple:

  1. You can kill all your own process.
  2. Only root user can kill system level process.
  3. Only root user can kill process started by other users.

Step 1 – Find out the PID (process id) of the lighttpd

Use the ps or pidof command to find out PID for any program. For example, if process name is lighttpd, you can use any one of the following command to obtain process ID: Sample outputs:

3486

OR Sample outputs:

lighttpd  3486  0.0  0.1   4248  1432 ?        S    Jul31   0:00 /usr/sbin/lighttpd -f /etc/lighttpd/lighttpd.conf
lighttpd  3492  0.0  0.5  13752  3936 ?        Ss   Jul31   0:00 /usr/bin/php5-cg

Step 2 – kill the process using a PID

The PID # 3486 is assigned to the lighttpd process. To kill the lighttpd server, you need to pass a PID as follows: OR This will terminate a process with a PID of 3486.

A note about sending stronger signal # 9 (SIGKILL)

If no signal specified in the kill command, signal # 15 (SIGTERM), is sent by default. So the kill 3486 command is same as the following command: OR Sometime signal # 15 is not sufficient. For example, lighttpd may not be killed by signal #15 due to open sockets. In that case process (PID) # 3486 would be killed with the powerful signal # 9: OR Where,

-9 or -SIGKILL – A special kill signal that nearly guarantee to kill the process with the iron fist.

How do I kill two or more Linux PIDs?

The syntax is as follows to kill two or more PIDs as required can be used in a single command:

kill  pid1 pid2 pid3
kill -15  pid1 pid2 pid3
kill -9  pid1 pid2 pid3
kill  -9 3546 5557 4242

COLOPHON top

       This page is part of release 5.08 of the Linux man-pages project.  A
       description of the project, information about reporting bugs, and the
       latest version of this page, can be found at
       https://www.kernel.org/doc/man-pages/.

Linux                            2019-10-10                          KILL(2)

Pages that refer to this page:
capsh(1), 
fuser(1), 
kill(1@@coreutils), 
kill(1), 
kill(1@@procps-ng), 
killall(1), 
pgrep(1), 
pkill(1), 
skill(1), 
snice(1), 
strace(1), 
clone2(2), 
__clone2(2), 
clone(2), 
clone3(2), 
exit(2), 
_exit(2), 
_Exit(2), 
fcntl(2), 
fcntl64(2), 
getpid(2), 
getppid(2), 
getrlimit(2), 
pause(2), 
pidfd_open(2), 
pidfd_send_signal(2), 
prlimit(2), 
prlimit64(2), 
ptrace(2), 
rt_sigaction(2), 
rt_sigpending(2), 
rt_sigprocmask(2), 
rt_sigqueueinfo(2), 
rt_sigreturn(2), 
rt_sigsuspend(2), 
rt_sigtimedwait(2), 
rt_tgsigqueueinfo(2), 
setfsgid(2), 
setfsgid32(2), 
setfsuid(2), 
setfsuid32(2), 
setrlimit(2), 
sigaction(2), 
signal(2), 
sigpending(2), 
sigprocmask(2), 
sigreturn(2), 
sigsuspend(2), 
sigtimedwait(2), 
sigwaitinfo(2), 
syscalls(2), 
tgkill(2), 
tkill(2), 
ugetrlimit(2), 
wait(2), 
waitid(2), 
waitpid(2), 
gsignal(3), 
killpg(3), 
psiginfo(3), 
psignal(3), 
pthread_kill(3), 
raise(3), 
sd_event_add_child(3), 
sd_event_add_child_pidfd(3), 
sd_event_child_handler_t(3), 
sd_event_source_get_child_pid(3), 
sd_event_source_get_child_pidfd(3), 
sd_event_source_get_child_pidfd_own(3), 
sd_event_source_get_child_process_own(3), 
sd_event_source_send_child_signal(3), 
sd_event_source_set_child_pidfd_own(3), 
sd_event_source_set_child_process_own(3), 
sigblock(3), 
siggetmask(3), 
sighold(3), 
sigignore(3), 
sigmask(3), 
sigpause(3), 
sigqueue(3), 
sigrelse(3), 
sigset(3), 
sigsetmask(3), 
sigvec(3), 
ssignal(3), 
vlimit(3), 
systemd.exec(5), 
systemd.kill(5), 
capabilities(7), 
cpuset(7), 
credentials(7), 
pid_namespaces(7), 
pthreads(7), 
signal(7), 
signal-safety(7)

Kill a Linux Program by Clicking the «X»

You’ve probably already tried walking away and making a hot drink. If you returned to your PC to find that the app is still hanging, it’s probably had enough time to start working again. An unresponsive app typically has grayed-out buttons, or options that don’t appear to work. You may also be unable to move the app window around the screen.

So, what is the solution? Click the X button in the top corner (left or right, depending on your Linux operating system). This should stop the program dead in its tracks. You might see a dialog box, asking you to Wait or Force Quit to end it now.

If all goes to plan, some distros will prompt you to send an error report.

Находим PID зависшего процесса

Каждый процесс в Linux имеет свой идентификатор, называемый PID. Перед тем, как выполнить остановку процесса, нужно определить его PID. Для этого воспользуемся командами ps и grep. Команда ps предназначена для вывода списка активных процессов в системе и информации о них. Команда grep запускается одновременно с ps (в канале) и будет выполнять поиск по результатам команды ps. Вывести список всех процессов можно, выполнив в командной строке:

 Но, как правило, список очень большой и найти процесс, который мы хотим «убить», бывает не так просто. Здесь на помощь приходит команда grep. Например, чтобы найти информацию о процессе с именем gcalctool выполните команду:

Команда grep выполнит поиск по результатам команды ps и на экран будут выведены только те строки, которые содержат строку (слово) gcalctool. Здесь есть одна интересная деталь, например, если у вас не запущено приложение gcalctool, то после выполнения ps axu | grep gcalctool вы получите:

То есть мы получили сам процесс grep, так как в качестве параметра команде мы указали слово gcalctool, и grep нашел сам себя в выводе команды ps.

Если процесс gcalctool запущен, то мы получим:

Здесь нас интересует строка: «yuriy 25609 7.6 0.4 500840 17964 ? Sl 10:20 0:00 gcalctool». Число 25609 и есть идентификатор (PID) процесса gcalctool.

Есть еще один более простой способ узнать PID процесса — это команда pidof, которая принимает в качестве параметра название процесса и выводит его PID. Пример выполнения команды pidof:

How To Use ps to List Processes

Both and provide a nice interface to view running processes similar to a graphical task manager.

However, these tools are not always flexible enough to adequately cover all scenarios. A powerful command called is often the answer to these problems.

When called without arguments, the output can be a bit lack-luster:

This output shows all of the processes associated with the current user and terminal session. This makes sense because we are only running and with this terminal currently.

To get a more complete picture of the processes on this system, we can run the following:

These options tell to show processes owned by all users (regardless of their terminal association) in a user-friendly format.

To see a tree view, where hierarchal relationships are illustrated, we can run the command with these options:

As you can see, the process is shown to be a parent of the process and the others.

A Note About Process IDs

In Linux and Unix-like systems, each process is assigned a process ID, or PID. This is how the operating system identifies and keeps track of processes.

A quick way of getting the PID of a process is with the command:

This will simply query the process ID and return it.

The first process spawned at boot, called init, is given the PID of “1”.

This process is then responsible for spawning every other process on the system. The later processes are given larger PID numbers.

A process’s parent is the process that was responsible for spawning it. Parent processes have a PPID, which you can see in the column headers in many process management applications, including , and .

Any communication between the user and the operating system about processes involves translating between process names and PIDs at some point during the operation. This is why utilities tell you the PID.

Parent-Child Relationships

Creating a child process happens in two steps: fork(), which creates new address space and copies the resources owned by the parent via copy-on-write to be available to the child process; and exec(), which loads an executable into the address space and executes it.

In the event that a child process dies before its parent, the child becomes a zombie until the parent has collected information about it or indicated to the kernel that it does not need that information. The resources from the child process will then be freed. If the parent process dies before the child, however, the child will be adopted by init, though it can also be reassigned to another process.

Kill Commands and Signals

When you execute a “kill” command, you are in fact sending a signal to the system to instruct it to terminate the misbehaving app. There is a total of sixty signals that you can use, but all you really need to know is SIGTERM (15) and SIGKILL (9).

You can view all the signals with the command:

  • SIGTERM – This signal requests that a process stop running. This signal can be ignored. The process is given time to gracefully shut down. When a program gracefully shuts down, that means it is given time to save its progress and release resources. In other words, it is not forced to stop.
  • SIGKILL – The SIGKILL signal forces the process to stop executing immediately. The program cannot ignore this signal. Unsaved progress will be lost.

The syntax for using is:

The default signal (when none is specified) is SIGTERM. When that doesn’t work, you can use the following to kill a process forcefully:

or

where the flag refers to SIGKILL signal.

If you are not aware of the PID of the application, simply run the command:

and it will display all the running applications together with its PID.

For example, to kill the Chrome app, run the command:

Do also note that you can kill multiple processes at the same time.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector