Команда renice в linux
Обновлено: 05.07.2024
Сервер Linux, как и любой другой компьютер, использует приложения. Компьютер рассматривает эти приложения как процессы.
Хотя Linux автоматически выполняет все скрытые низкоуровневые задачи жизненного цикла процесса, нам необходим способ взаимодействия с операционной системой для управления на более высоком уровне.
В этом учебном модуле мы расскажем о некоторых простых аспектах управления процессами. Linux предоставляет широкий выбор инструментов для этой цели.
В качестве примера мы используем Ubuntu 12.04 VPS, но любые современные дистрибутивы Linux будут работать аналогичным образом.
Просмотр запущенных процессов в Linux
Чтобы посмотреть, какие процессы запущены на вашем сервере, нужно запустить команду top :
В верхней части подборки приведена статистика по системе, в том числе сведения о нагрузке и общем количестве задач.
Вы можете легко увидеть, что в системе запущен 1 процесс, а 55 процессов находятся в режиме сна (т. е. не активны/не используют ресурсы ЦП).
В нижней части отображаются запущенные процессы и статистика их использования.
В репозиториях доступна улучшенная версия top , которая называется htop . Установите ее с помощью следующей команды:
Если мы запустим команду htop , мы увидим отображение информации в более удобном формате:
Использование ps для вывода перечня процессов
И top , и htop предоставляют удобный интерфейс для просмотра работающих процессов, похожий на графический диспетчер задач.
Однако эти инструменты не всегда достаточно гибкие, чтобы охватывать все сценарии. Решить эту проблему может помочь мощная команда ps .
При вызове без аргументов вывод может быть довольно сжатым:
Вывод показывает все процессы, связанные с текущим пользователем и текущим сеансом терминала. Это имеет смысл, потому что мы запускаем на этом терминале только bash и ps .
Чтобы получить более полное представление о процессах в данной системе, мы можем использовать следующую команду:
Эти опции предписывают ps показать процессы, принадлежащие всем пользователям (вне зависимости от привязки терминала) в удобном формате.
Чтобы посмотреть представление дерева с иллюстрацией иерархических отношений, данную команду можно запустить с этими опциями:
Как видите, процесс kthreadd отображается как родитель процесса ksoftirqd/0 и других процессов.
Примечание об идентификаторах процессов
В системах Linux и Unix каждому процессу назначается идентификатор процесса или PID. Операционная система использует их для идентификации и отслеживания процессов.
Чтобы быстро узнать PID процесса, вы можете использовать команду pgrep :
Эта команда просто запросит идентификатор процесса и выведет его.
Процессу init, который создается первым при загрузке, присваивается PID “1”.
Этот процесс отвечает за создание всех остальных процессов в системе. Последующим процессам присваиваются большие номера PID.
Родитель процесса — это процесс, который отвечает за его создание. Родительские процессы имеют идентификатор PPID, который можно увидеть в заголовках столбцов многих приложений для управления процессами, включая top , htop и ps .
Любое взаимодействие между пользователем и операционной системой, связанное с процессами, включает взаимное преобразование имен процессов и PID. Именно поэтому утилиты сообщают вам PID.
Отношения родительских и дочерних элементов
Создание дочернего процесса осуществляется в два этапа: fork() создает новое адресное пространство и копирует в него ресурсы, принадлежащие родительскому процессу, с помощью copy-on-write; а exec() загружает исполняемый блок в адресное пространство и выполняет его.
Если дочерний процесс завершается раньше родительского, он остается бесхозным, пока родитель не получит информацию о нем или не сообщит ядру, что эта информация не требуется. В этом случае ресурсы дочернего процесса освободятся. Если родительский процесс завершается раньше дочернего, дочерний процесс привязывается к процессу init, хотя его можно переназначить другому процессу.
Отправка сигналов процессам в Linux
Отправка сигналов процессам по PID
Наиболее распространенный способ передачи сигналов в программу — использовать команду kill .
Как вы можете догадаться, по умолчанию эта утилита пытается уничтожить процесс:
Она отправляет процессору сигнал TERM. Сигнал TERM просит процесс остановиться. Это позволяет программе выполнить операции по очистке и нормально завершить работу.
Это специальный сигнал, который не отправляется программе.
Вместо этого он передается в ядро операционной системы, которое отключает процесс. Он используется, чтобы обходить программы, игнорирующие отправляемые им сигналы.
Каждому сигналу присвоено число, которое можно передать вместо имени. Например, вы можете передать “-15” вместо “-TERM” и “-9” вместо “-KILL”.
Использование сигналов для других целей
Сигналы используются не только для отключения программ. Их также можно использовать для выполнения других действий.
Например, многие демоны перезапускаются при получении сигнала HUP или прекращения работы. Например, так работает Apache.
<pre>sudo kill -HUP <span >
Получив вышеуказанную команду, Apache перезагрузит файл конфигурации и возобновит вывод контента.
Вы можете вывести список сигналов, которые можно отправлять с помощью kill, используя следующую команду:
Отправка сигналов процессам по имени
Хотя обычно при отправке сигналов используются PID, существуют способы использовать для этой же цели обычные имена процессов.
Команда pkill работает практически точно так же как и kill , но использует имя процесса:
Вышеуказанная команда эквивалентна команде:
Приведенная выше команда отправит сигнал TERM всем экземплярам firefox, запущенным на этом компьютере.
Настройка приоритетов процессов
Часто бывает необходимо изменить приоритет процессов в серверной среде.
Некоторые процессоры могут быть важными, а другие могут выполняться на излишках ресурсов.
Linux контролирует приоритеты с помощью значения вежливости.
Приоритетные задачи считаются менее вежливыми, потому что они вообще не делятся ресурсами. Процессы с низким приоритетом считаются более вежливыми, потому что они используют минимум ресурсов.
Когда мы запускали команду top в начале этого учебного модуля, мы видели столбец “NI”. В этом столбце отображается значение вежливости процесса:
В зависимости от системы, значения вежливости могут различаться от “-19/-20” (наибольший приоритет) до “19/20” (наименьший приоритет).
Чтобы запустить программу с определенным значением вежливости, мы можем использовать команду nice :
Это работает только в начале новой программы.
Чтобы изменить значение вежливости уже выполняемой программы, мы используем инструмент renice :
Примечание. Хотя nice по необходимости использует имя команды, renice вызывает PID процесса.
Заключение
Управление процессами — это тема, которая иногда бывает сложной для новых пользователей, потому что используемые для этой цели инструменты отличаются от аналогичных инструментов с графическим интерфейсом.
Однако все эти идеи знакомы, интуитивно понятны и станут привычными после небольшой практики. Поскольку процессы используются в компьютерных системах повсеместно, умение эффективно управлять ими — критически важный навык.
Когда на компьютере достаточно процессорного времени на исполнение всех процессов, нет необходимости в выставлении приоритетов. Но когда необходимо параллельно запустить несколько процессов, каждый из которых использует всё доступное процессорное время, может очень пригодиться утилита nice.
Команда nice запускает программу с изменённым приоритетом для планироващика задач. Слово «nice» в английском языке обозначает, в частности, «вежливый». По этимологии этой команды процесс с большим значением nice — более вежлив к другим процессам, позволяя им использовать больше процессорного времени, поскольку он сам имеет меньший приоритет (и, следовательно, большее «значение вежливости» — niceness value).
Наибольший приоритет (и наименьшее значение nice) — −20. 19, либо 20 — наименьший приоритет, но это, с другой стороны, самые вежливые процессы.
Чтобы посмотреть идентификатор и значение nice нужного процесса в системе, можно воспользоваться командой ps axl.
Пример использования команды nice — запуск ресурсоёмкой задачи в фоновом режиме, так, чтобы она выполнялась, но освобождала часть процессорного времени для других процессов, как только оно становятся им нужно. Таким образом можно, скажем, запустить кодирование OGG/MP3 с большим значением nice, чтобы оно происходило в фоновом режиме, используя не всё процессорное время, а то, что не используется другими процессами (с меньшим значением nice — то есть с большим приоритетом).
Чтобы запустить команду с определённым приоритетом, слева нужно добавить «nice -n значение_nice», либо «nice --adjustment значение_nice» (adjustment — настройка, регулировка).
То есть: nice -n значение_nice команда.
Если нужно изменить приоритет уже запущенного процесса, можно воспользоваться командой renice.
renice -n значение_nice id_процесса
Команда renice выводит старый и новый приоритет процесса.
Теперь, зная эти команды, можно управлять процессами так, чтобы определённые задачи выполнялись быстрее в случае, когда сразу много процессов используют всё доступное процессорное время.
На сервере Linux, как и на любой другой машине, можно запускать приложения. Компьютер рассматривает их как так называемые «процессы».
В то время как Linux обрабатывает низкоуровневое закадровое управление жизненным циклом процесса, пользователю может понадобиться другой способ взаимодействия с операционной системой для управления процессом на более высоком уровне.
Данное руководство затрагивает некоторые простейшие аспекты управления процессами. Для этого Linux предоставляет широчайший набор инструментов.
Данные понятия будут рассмотрены на примере сервера Ubuntu 12.04, но любой современный дистрибутив Linux будет работать таким же образом.
Как просматривать запущенные процессы в Linux
top
top - 15:14:40 up 46 min, 1 user, load average: 0.00, 0.01, 0.05
Tasks: 56 total, 1 running, 55 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.0%sy, 0.0%ni,100.0%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 1019600k total, 316576k used, 703024k free, 7652k buffers
Swap: 0k total, 0k used, 0k free, 258976k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 24188 2120 1300 S 0.0 0.2 0:00.56 init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kthreadd
3 root 20 0 0 0 0 S 0.0 0.0 0:00.07 ksoftirqd/0
6 root RT 0 0 0 0 S 0.0 0.0 0:00.00 migration/0
7 root RT 0 0 0 0 S 0.0 0.0 0:00.03 watchdog/0
8 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 cpuset
9 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 khelper
10 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kdevtmpfs
Верхняя часть выведенной информации предоставляет статистические данные системы, а именно нагрузку на систему и общее количество задач.
Можно увидеть, что 1 процесс запущен, а 55 процессов находятся в режиме ожидания (иначе говоря, простаивают, не используя ресурсы процессора).
Нижняя часть полученной информации отображает запущенные процессы и статистику по их использованию.
Усовершенствованная версия команды top под названием htop доступна в хранилищах. Чтобы установить ее, используйте данную команду:
sudo apt-get install htop
Запустив команду htop, можно увидеть более удобное для пользователя отображение информации:
htop
Mem[||||||||||| 49/995MB] Load average: 0.00 0.03 0.05
CPU[ 0.0%] Tasks: 21, 3 thr; 1 running
Swp[ 0/0MB] Uptime: 00:58:11
PID USER PRI NI VIRT RES SHR S CPU% MEM% TIME+ Command
1259 root 20 0 25660 1880 1368 R 0.0 0.2 0:00.06 htop
1 root 20 0 24188 2120 1300 S 0.0 0.2 0:00.56 /sbin/init
311 root 20 0 17224 636 440 S 0.0 0.1 0:00.07 upstart-udev-brid
314 root 20 0 21592 1280 760 S 0.0 0.1 0:00.06 /sbin/udevd --dae
389 messagebu 20 0 23808 688 444 S 0.0 0.1 0:00.01 dbus-daemon --sys
407 syslog 20 0 243M 1404 1080 S 0.0 0.1 0:00.02 rsyslogd -c5
408 syslog 20 0 243M 1404 1080 S 0.0 0.1 0:00.00 rsyslogd -c5
409 syslog 20 0 243M 1404 1080 S 0.0 0.1 0:00.00 rsyslogd -c5
406 syslog 20 0 243M 1404 1080 S 0.0 0.1 0:00.04 rsyslogd -c5
553 root 20 0 15180 400 204 S 0.0 0.0 0:00.01 upstart-socket-br
Как использовать ps для получения списка процессов
Команды top и htop предоставляют удобный интерфейс для просмотра запущенных процессов, аналогичный графическому диспетчеру задач.
Тем не менее, данные инструменты не всегда достаточно гибки, чтобы адекватно охватить все сценарии.
При вызове без аргументов результаты могут быть немного неполными:
ps
PID TTY TIME CMD
1017 pts/0 00:00:00 bash
1262 pts/0 00:00:00 ps
Эти данные отображают все процессы, связанные с текущим пользователем и терминальной сессией. Это имеет смысл, так как в данный момент с терминала запущены только команды bash and ps.
Чтобы получить более полную картину процессов данной системы, можно запустить следующее:
ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.2 24188 2120 ? Ss 14:28 0:00 /sbin/init
root 2 0.0 0.0 0 0 ? S 14:28 0:00 [kthreadd] root 3 0.0 0.0 0 0 ? S 14:28 0:00 [ksoftirqd/0] root 6 0.0 0.0 0 0 ? S 14:28 0:00 [migration/0] root 7 0.0 0.0 0 0 ? S 14:28 0:00 [watchdog/0] root 8 0.0 0.0 0 0 ? S< 14:28 0:00 [cpuset] root 9 0.0 0.0 0 0 ? S< 14:28 0:00 [khelper] . . .
Эти параметры приказывают ps показать процессы, принадлежащие всем пользователям (вне зависимости от их терминала) в удобном формате.
Чтобы увидеть дерево, отображающее иерархические отношения, можно запустить команду с данными параметрами:
ps axjf
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
0 2 0 0 ? -1 S 0 0:00 [kthreadd] 2 3 0 0 ? -1 S 0 0:00 \_ [ksoftirqd/0] 2 6 0 0 ? -1 S 0 0:00 \_ [migration/0] 2 7 0 0 ? -1 S 0 0:00 \_ [watchdog/0] 2 8 0 0 ? -1 S< 0 0:00 \_ [cpuset] 2 9 0 0 ? -1 S< 0 0:00 \_ [khelper] 2 10 0 0 ? -1 S 0 0:00 \_ [kdevtmpfs] 2 11 0 0 ? -1 S< 0 0:00 \_ [netns] . . .
Как можно видеть, процесс kthreadd отображен как порождающий относительно процесса ksoftirqd/0 и других.
Примечание об идентификаторах процессов (PID)
В Linux и Unix-подобных системах каждому процессу присвоен идентификатор (PID). Таким образом операционная система идентифицирует и отслеживает процессы.
Быстрый способ узнать PID процесса – использовать команду pgrep:
pgrep bash
1017
Это запросит идентификатор процесса и вернет его.
Первый порожденный при запуске процесс под названием init получает PID «1».
Данный процесс отвечает за порождение всех остальных процессов системы. Чем позже порожден процесс, тем больше будет присвоенный ему PID.
Родительский процесс – это процесс, ответственный за порождение другого процесса. Если порождающий процесс был прекращен, то дочерние процессы также прервутся. PID родительского процесса называется PPID.
PID и PPID можно увидеть в заголовках столбцов во многих приложениях управления процессами, включая top, htop и ps.
Любое общение между пользователем и операционной системой, связанное с процессами, предполагает перевод имен процессов в их идентификаторы и наоборот. Вот зачем утилиты сообщают PID.
Как отправлять сигналы процессам в Linux
Все процессы в Linux отвечают на сигналы.
Как отправлять процессам сигналы при помощи PID
Наиболее распространенным способом передачи сигналов программам является команда kill.
Как и следовало ожидать, функциональность данной утилиты по умолчанию заключается в попытке завершить процесс:
Это отправит всем процессам сигнал TERM. Данный сигнал приказывает процессу завершиться. Это позволяет программе выполнять операции по очистке и завершить работу без помех.
Если программа неисправна и не завершает работу при отправке сигнала TERM, можно усилить сигнал, передав сигнал KILL:
kill -KILL PID_of_target_process
Данный специальный сигнал отправляется не программе.
Вместо этого он передается ядру операционной системы, которое прерывает процесс. Это используется для блокировки программ, которые игнорируют сигналы, посылаемые им.
Как использовать сигналы для других целей
Сигналы используются не только для завершения работы программ. Они также полезны для совершения других действий.
К примеру, многие демоны можно перезапустить при помощи сигнала отбоя HUP. Apache является одной из работающих по такому принципу программ.
sudo kill -HUP pid_of_apache
Вышеприведенная команда заставит Apache перезагрузить конфигурационный файл и возобновить обслуживание контента.
kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
. . .
Как отправлять сигналы процессам по имени
Хотя отправлять сигналы процессам гораздо удобнее при помощи PID, существуют также методы отправки сигнала с помощью имен процессов.
Команда pkill работает почти также, как kill, но она действует от имени процесса:
Команда, приведенная выше, является эквивалентом:
kill -9 `pgrep ping`
Чтобы послать сигнал каждому экземпляру определенного процесса, используйте команду killall:
Вышеуказанная команда отправит сигнал TERM каждому экземпляру firefox, запущенному на данном компьютере.
Как установить приоритеты процессов
Часто возникает необходимость установить, какие процессы имеют приоритет в серверной среде.
Некоторые процессы могут рассматриваться как критически важные, в то время как другие могут быть выполнены за счет остатка ресурсов.
Linux контролирует приоритеты с помощью значения под названием niceness.
Задачи с высоким приоритетом имеют низшее значение nice, так как они поглощают ресурсы. С другой стороны, задачи с низким приоритетом имеют высокое значение nice, так как они используют минимальное количество ресурсов.
При запуске команды top в начале статьи был выведен столбец, отмеченный как «NI». В нем указывается значение nice процесса:
top
Tasks: 56 total, 1 running, 55 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 1019600k total, 324496k used, 695104k free, 8512k buffers
Swap: 0k total, 0k used, 0k free, 264812k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1635 root 20 0 17300 1200 920 R 0.3 0.1 0:00.01 top
1 root 20 0 24188 2120 1300 S 0.0 0.2 0:00.56 init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kthreadd
3 root 20 0 0 0 0 S 0.0 0.0 0:00.11 ksoftirqd/0
В зависимости от системы, значение nice может варьироваться от «-19/-20» (наивысший приоритет) до «19/20» (самый низкий приоритет).
Чтобы запустить программу с определенным значением nice, можно использовать команду nice:
nice -n 15 command_to_execute
Это работает только при запуске новой программы.
Чтобы изменить значение nice программы, которая уже выполняется, нужно использовать инструмент renice:
renice 0 PID_to_prioritize
Примечание: в то время как nice работает с именем команды, renice вызывает PID процесса.
Итоги
Управление процессами – иногда достаточно сложная для новичков тема, так как используемые инструменты отличаются от их графических эквивалентов.
Однако концепции знакомы и интуитивно понятны, и, немного попрактиковавшись, их можно легко освоить. Поскольку процессы участвуют во всем, что касается компьютерной системы, очень важно научиться управлять ими.
Команды nice и renice позволяют вам точно настроить, как ядро обрабатывает ваши процессы, регулируя их приоритеты. Прочтите это руководство, чтобы узнать, как использовать их в Linux и Unix-подобных операционных системах, таких как macOS.
Все дело в процессе
Внутри вашего Linux или Unix-подобного компьютера будет много процессов, запущенных даже до того, как вы запустите приложение, которое хотите использовать. Большинство из этих процессов являются жизненно важными элементами самого Linux или поддерживающими процессами для вашей графической среды рабочего стола. За кулисами происходит много всего. Конечно, есть только так много системных ресурсов и процессорного времени. Ядро Linux является контроллером для всех этих процессов.
Именно ядро должно решить, какие процессы сейчас привлекают внимание и ресурсы, а какие ждать. Ядро постоянно манипулирует процессами и приоритетами, чтобы обеспечить максимальную бесперебойную работу компьютера и чтобы все процессы получили соответствующую долю. Некоторые процессы получают льготное лечение. Они настолько важны для общей работы компьютера, что их потребности должны идти впереди, скажем, вашего браузера.
Хорошее Значение
Одним из критериев, используемых для определения того, как ядро обрабатывает процесс, является приятное значение. Каждый процесс имеет приятную ценность. Хорошее значение — это целое число в диапазоне от -19 до 20. Все стандартные процессы запускаются с хорошим значением, равным нулю.
Хитрость в том, что чем выше приятное значение, тем приятнее ваш процесс по отношению к другим процессам. Другими словами, высокое значение nice говорит ядру, что этот процесс с удовольствием ждет. Отрицательное число противоположно тому, чтобы быть хорошим. Чем больше отрицательное значение, тем эгоистичнее этот процесс. Он пытается получить как можно больше процессорного времени, не обращая внимания на другие процессы.
Мы можем использовать команду nice для установки значения nice при запуске процесса, и мы можем использовать renice для настройки значения nice запущенного процесса .
Хорошая команда
Мы можем использовать команду nice чтобы настроить значение nice для программы при ее запуске. Это позволяет нам увеличивать или уменьшать приоритет, данный процессу ядром, по сравнению с другими процессами.
Давайте предположим, что программист написал программу под названием ackermann . Это вычисляет функции Аккермана . Это процессор и интенсивное использование памяти. Программист может запустить программу с помощью следующей команды:
Мы можем использовать команду top для просмотра работающей программы.
Мы можем видеть детали программы ackermann в top . Хорошее значение — это цифра в «NI столбце». Он установлен на ноль, как и следовало ожидать.
Давайте перезапустим его и на этот раз сделаем его менее требовательным Мы установим хорошее значение 15 для программы ackermann следующим образом. Введите nice, пробел, -15, другой пробел, а затем название программы, которую вы хотите запустить. В нашем примере наш вымышленный программист использует ./ackermann .
Обратите внимание, «-15» не является отрицательным пятнадцать. Это положительный пятнадцать. «-» требуется, чтобы сказать, что мы передаем параметр. Чтобы указать отрицательное число, вы должны ввести два символа «-».
Если мы теперь начнем снова с top , мы увидим изменение в поведении ackermann .
С хорошим значением 15, ackermann не потребляет большую часть процессорного времени. GNOME и Rhythmbox используют больше. Мы немного ackermann .
Теперь давайте сделаем обратное и ackermann отрицательное значение nice. Обратите внимание на использование двух символов «-». Чтобы сделать приложение более эгоистичным и менее приятным, вы должны использовать sudo . Любой может сделать свое приложение более приятным, но только суперпользователи могут сделать еще одного эгоиста.
Давайте побежим и посмотрим, что это изменило.
На этот раз ackermann имеет хорошее значение -10. Он вернулся на верхнюю строчку и потребляет больше процессорного времени, чем раньше.
Команда Renice
Команда renice позволяет нам настроить приятное значение запущенного процесса. Нам не нужно останавливать его и перезапускать с nice . Мы можем установить новое значение на лету.
Команда renice принимает идентификатор процесса или PID процесса в качестве параметра командной строки. Мы можем либо извлечь идентификатор процесса из столбца «PID» top , либо использовать ps и grep чтобы найти его для нас следующим образом. Очевидно, вы будете вводить имя вашего пользователя вместо dave и имя процесса, который вас интересует, вместо ackermann .
Теперь, когда у нас есть PID, мы можем использовать это с renice . Мы ackermann к более ackermann поведению с хорошим значением пять. Чтобы изменить значение nice для запущенного процесса, вы должны использовать sudo . Обратите внимание, что в параметре 5 нет «-». Вам не нужен один для положительных чисел, и вам нужен только один, а не два, для отрицательных чисел.
Мы получаем подтверждение того, что стоимость renice изменилась. Это показывает нам старое значение и новое значение.
Ядро обычно отлично справляется с обработкой приоритетов и распределением процессорного времени и системных ресурсов. Но если у вас есть длинная задача, требующая значительных ресурсов процессора, и вам все равно, когда она завершится, ваш компьютер будет работать немного плавнее, если вы установите более высокое значение для этой задачи. Это будет лучше для всех.
Читайте также: