Как закрыть личку: Как закрыть личку в ВК на телефоне и компьютере

Содержание

Как запретить кому-либо присылать мне личные сообщения в Twitter

Социальные сети

0 689 3 минут на чтение

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

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

Но мы скажем вам, что это не должно доставлять неудобств, потому что есть также очень простой способ

запретить кому-либо отправлять мне личные сообщения на Twitter .

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

Как запретить кому-либо присылать мне личные сообщения в Twitter

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

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

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

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

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

Как запретить кому-либо отправлять мне личные сообщения в Twitter

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

Первое, что нужно сделать, это открыть приложение Twitter со своего персонального компьютера, и вы разъем . Затем вам нужно перейти непосредственно в меню «Настройки» и оттуда найти и выбрать раздел «Безопасность и конфиденциальность». Это действие приведет вас в новое окно, где вы найдете множество параметров конфигурации в этом разделе.

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

Теперь вы будете получать личные сообщения только от подписчиков, и у вас не будет проблем с получением сообщений от иностранцы.

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

Подобные предметы

переслать, удалить, закрепить,написать в личку

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

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

Содержание (кликабельно):
1. Переслать сообщение в Телеграм
2. Поделиться сообщением
3. Как закрепить и удалить сообщение
4. Как написать в личку
5. Видео: Сообщение в телеграм можно переслать, поделиться, закрепить, а также удалить. Как написать в личку?

Переслать сообщение в Телеграм

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

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

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

Рис. 1. Команда «Переслать» для сообщения в Телеграм и еще справа внизу кнопка «Поделиться». Другие действия с сообщением, в том канале, на который вы подписаны.

На рис. 1 видно, что в меню есть команда «Переслать». Кликаем левой кнопкой мыши на компьютере или тапаем пальцем на телефоне по этой команде. Появится окно «Выберите получателя» (рис. 2).

Рис. 2. Чтобы переслать сообщение, выберите получателя вашей информации.

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

Следует кликнуть по нужному контакту. Появится ссылка на пересылаемое сообщение, а также поле для ввода текста (рис. 3).

Рис. 3. Подготовка к отправке сообщения, которое нужно переслать.

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

Для окончательной пересылки сообщения следует кликнуть на кнопку в виде самолетика (в красной рамке на рис. 3). На компьютере можно нажать на клавишу Enter.

Поделиться сообщением

Какая разница между командой «Переслать» и кнопкой «Поделиться»? Поделиться можно сообщениями в каналах Телеграма, на которые человек подписался. А в личном чате можно только переслать сообщение.

В конце каждого сообщения в каком-либо канале, справа есть стрелка — это кнопка «Поделиться». Она обведена в красную рамку на рис. 1. Кликаем на эту кнопку. Появится окно с заголовком «Поделиться».

Рис. 4. Если кликнуть на стрелку «Поделиться», появится окно, в котором следует найти получателя сообщения.

После того, как в окне «Поделиться» будет найден получатель сообщения, можно при желании ввести небольшой текст в качестве пояснения, но это не обязательно. Место для ввода текста показано на рис. 4 с помощью зеленой стрелки. Осталось только нажать «Отправить» и вы мгновенно поделитесь сообщением с получателем.

Как закрепить и как удалить сообщение

Можно закрепить сообщение только на своем канале или в личном чате с кем-либо. Если телефон, то удерживаем палец на сообщении до появления меню (рис. 5). На компьютере кликаем ПКМ (правой кнопкой мыши) по сообщению, и появится меню.

Рис. 5. Можно удалить или закрепить сверху сообщение.

Для закрепления сообщения достаточно только клика по команде «Закрепить» (рис. 5).

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

Для удаления держим палец на сообщении на телефоне, либо щелкаем правой кнопкой мыши на компьютере. Появится меню, затем нажать на команду «Удалить».

Рис. 6. Если галочка есть, то в личном чате можно удалить сообщение у обоих участников одновременно.

В личном чате есть возможность удалить сообщение не только в своем чате, но и в чате получателя, то есть, удалить у обоих. Для этого нужно поставить галочку напротив «Удалить у …» (будет указано имя). Тогда удаление сообщения произойдет и в вашем чате, и в чате получателя (рис. 6).

Если галочку убрать, то сообщение будет удалено только у вас, а у второго собеседника оно останется.

Как написать в личку

В личку можно написать в случае, если человек есть в ваших «Контактах». Если его там нет, то в некоторых каналах пишут примерно так: «Напишите мне в личку». И после этого указывают, куда писать, например, @nadezda.

Чтобы написать в личку пользователю, который есть в вашей папке «Контакты», в своем Телеграме кликните на значок меню (рис. 7) в левом верхнем углу.

Рис. 7. Меню Телеграм обведено в рамку.

Открываем меню и видим, что там есть папка «Контакты» (рис. 8).

Рис. 8. Папка «Контакты» находится в меню Телеграм.

Кликаем на «Контакты» и ищем (скроллим вниз), чтобы найти человека, которому нужно написать в личку (рис. 9).

Рис. 9. Поиск нужного контакта в Телеграм.

Щелкаем на подходящий контакт. Появится поле «Написать сообщение» (рис. 10), в котором вводим текст и отправляем его.

Рис. 10. Написать в личку в Телеграм.

Приглашаю в Телеграм канал «Компьютерная грамотность с Надеждой«.

Видео: Сообщение в телеграм можно переслать, поделиться, закрепить, а также удалить. Как написать в личку?

https://youtu.be/iaBLfS4zy4Y
Спасибо за внимание! Если есть вопрос, напишите в комментарии к статье.

Дополнительно:

1. Telegram — спасение для старого телефона?

2. Что такое Google Hangouts и как им пользоваться на компьютере или на телефоне

3. Как перевести Телеграм на русский язык или на другой язык

Получайте новые статьи по компьютерной грамотности на ваш почтовый ящик:

Необходимо подтвердить подписку в своей почте. Спасибо!

Как закрыть поток в Python

Вы можете закрыть новый поток , вернувшись из run() или вызвав исключение.

В этом руководстве вы узнаете, как закрыть поток в Python .

Начнем.

Содержание

Необходимо закрыть поток

Поток — это поток выполнения в компьютерной программе.

Каждая программа Python имеет по крайней мере один поток выполнения, называемый основным потоком. И процессы, и потоки создаются и управляются базовой операционной системой.

Иногда нам может понадобиться создать дополнительные потоки в нашей программе для одновременного выполнения кода.

Python предоставляет возможность создавать новые потоки и управлять ими с помощью модуля threading и класса threading.Thread .

Вы можете узнать больше о потоках Python в руководстве:

Создание потоков в Python: полное руководство

При выполнении функции в новом потоке может потребоваться немедленная остановка потока.

Это может быть вызвано многими причинами, например:

В зависимости от условия или состояния в приложении.
Зависимый ресурс больше недоступен.
Пользователь запрашивает закрытие программы.

Как мы можем немедленно закрыть новую тему?

Как закрыть новый поток

Новый поток будет закрыт, когда функция run() класса threading.Thread вернется.

Это может произойти одним из двух способов:

Функция run() возвращается нормально.
Функция run() вызывает необнаруженную ошибку или исключение.

Мы можем вернуть или вызвать необработанное исключение, чтобы закрыть поток, и это можно реализовать несколькими способами, например:

Вызов возврата из целевой функции задачи.
Вызов system.exit() .
Вызов Ошибка или Исключение .

Рассмотрим каждый подробнее.

Подход 1. Закрыть поток по возврату

Функция run() класса threading.Thread выполнит нашу целевую функцию в новом потоке выполнения.

Рассмотрим случай, когда мы создаем новый поток и настраиваем его для выполнения пользовательской функции task() с помощью аргумента « target ». Затем поток запускается вызовом функции start() .

Например:

# функция задачи

def task():

# …

…

# создать новый поток для запуска пользовательской функции

thread = threading.Thread(target=task)

# запустить поток

thread.start()

В этом случае start() 9Функция 0004 выполняет функцию run() класса threading. Thread в новом потоке и немедленно возвращается.

Функция run() потока . Класс Thread вызовет нашу функцию task() . Наша функция задачи в конце концов вернется, затем вернется функция запуска, и поток завершится.

Это нормальное использование потока.

Мы можем закрыть поток в любое время из нашей функции задачи.

Этого можно добиться, вернувшись из функции задачи.

Например:

# функция задачи

def task():

# выполнение задачи

…

# определение необходимости закрытия потока

if condition:

return

Это завершит поток.

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

Вы можете узнать больше о запуске потока для остановки из другого потока в этом руководстве:

Как остановить поток в Python

Подход 2.

Закрытие потока с помощью sys.exit()
Другой подход — вызов функцию sys.exit() в любой точке нашей функции task() или в функциях, которые она вызывает.
Это поднимет Исключение SystemExit , которое не будет перехвачено и завершит новый поток.
Например:
1
2
3
4
5
6
7
# функция задачи
def task():
# выполнение задачи
…
# определение необходимости закрытия потока
if condition:
sys.exit()
Этот подход полезен, если мы находимся глубоко в графе вызовов пользовательских функций, а оператор return неудобен.
Подход 3. Закрыть поток по исключению
Другой подход — вызвать Error или Exception в целевой функции или любой вызываемой функции.
Если Error или Exception не перехвачены, он распутывает граф вызовов потока, а затем завершает поток.
Например:
1
2
3
4
5
6
7
# функция задачи
def task():
# выполнение задачи
…
# определение необходимости закрытия потока
Недостатком этого подхода является то, что обработчик по умолчанию для неперехваченных исключений сообщит об исключении на терминал. Это можно изменить, указав обработчик через threading.excepthook .
Вы можете узнать больше о необработанных исключениях в потоках здесь:
Обработка непредвиденных исключений в потоках с помощью excludehook
Теперь, когда мы знаем, как закрыть поток изнутри потока, давайте рассмотрим некоторые рабочие примеры.
Запутался в API модуля потоков?
Загрузите мою БЕСПЛАТНУЮ шпаргалку в формате PDF
Закрыть поток, вернувшись
Мы можем закрыть поток, вернувшись из функции запуска в любое время.
Этого можно добиться, используя оператор « return » в нашей целевой функции задачи.
Если класс threading.Thread был расширен и функция run() переопределена, то оператор « return » может использоваться непосредственно в функции run() .
Мы можем продемонстрировать это на рабочем примере.
В этом примере у нас будет задача, которая зацикливается бесконечно. На каждой итерации он будет генерировать случайное число от 0 до 1, сообщать значение, а затем засыпать на долю секунды. Если сгенерированное значение больше 0,9, то поток решит немедленно закрыться.
Функция task() ниже реализует это.
1
2
3
4
5
6
7
8
10
11
12
13
# функция задачи
def task():
    # бесконечный цикл
    пока True:
        # генерирует случайное значение от 0 до 1
value = random ()
print (f ‘. {Value}’)
# block
Sleep (значение)
# Проверьте, если мы должны насильственно закрыть поток
, если значение> 0,9:
Печать («Закрытие темы»)
            возврат
Затем основной поток может создать и настроить новый экземпляр threading.Thread для запуска нашей функции task() в новом потоке выполнения.
…
# создать и настроить новый поток
thread = Thread(target=task)
Затем можно запустить поток, а основной поток может дождаться завершения нового потока, прежде чем продолжить работу.
…
# запустить новый поток
thread.start()
# дождаться завершения потока
thread.join()
Затем основной поток может продолжить выполнение других задач.
. ..
# main continue on
print(‘Main continue on…’)
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# SuperFastPython.com
# пример закрытия потока путем возврата
из random import random
от импорта времени импорт Sleep
Из потока импорта импорта
Import Sys
# Функция задачи
DEF ():
# Цикл навсегда
В то время как TRUE:
# Создайте случайное значение между 0 и 1.
        value = random()
        print(f’.{value}’)
        # block
        sleep check(value)
        0002, если значение> 0,9:
Печать (‘Поток закрытия’)
Возврат
# Создание и настройка новой потоки
Thread = Thread (Target = Task)
# Запустите новую потоку
. start()
# дождаться завершения потока
thread.join()
# main continue on
print(‘Main continue on…’)
При выполнении примера создается и настраивается новый поток. Запускается новый поток, затем основной поток блокируется до тех пор, пока новый поток не закроется.
Задача выполняется в новом потоке, зацикленном навсегда. На каждой итерации генерируется и сообщается случайное число. Если число выше порога, функция возвращает значение. Затем функция run() для потока возвращается, и поток завершается.
Затем основной поток разблокируется и продолжает выполнять другие задачи.
Здесь показано, как обычно закрывать поток с помощью оператора return.
Ниже приведен усеченный пример вывода программы.
Обратите внимание, ваши конкретные результаты будут отличаться из-за использования случайных чисел. Попробуйте запустить пример несколько раз.
1
2
3
4
5
6
7
8
. 0.528207
99525
.0.19715272036324882
.0.8454003559942119
.0.8540936983532249
.0.07015418965671016
.0.9969627310024305
Закрывающая резьба
Основное продолжение…
Далее давайте посмотрим, как можно закрыть новый поток, вызвав sys.exit() .
Бесплатный курс Python Threading Course
Загрузите мою памятку по Threading API, и в качестве бонуса вы получите БЕСПЛАТНЫЙ доступ к моему 7-дневному электронному курсу.
Узнайте, как использовать модуль потоковой обработки Python, в том числе как создавать и запускать новые потоки, а также как использовать мьютексы и семафоры
Подробнее

Закрыть поток с помощью sys.exit()
Поток можно закрыть, вызвав функцию sys.exit() .
Функция sys.exit() вызовет исключение SystemExit , которое не будет перехвачено и завершит поток.
Мы можем вызвать эту функцию в новом потоке, чтобы немедленно завершить поток.
Этот подход к закрытию потока полезен, если наша целевая функция задачи, выполняемая в новом потоке, сама вызвала функцию и находится глубже в графе вызовов, что делает оператор return неэффективным при завершении потока.
Пример из предыдущего раздела может быть обновлен для вызова sys.exit() вместо возврата.
Например:
…
# проверить, должны ли мы принудительно закрыть поток
если значение > 0.9:
    print(‘Закрытие потока’)
    sys.exit()
Обновленная функция task() с этим изменением указана ниже.
1
2
3
4
5
6
7
8
10
11
12
13
# Функция задачи
def Task ():
# LOOP Forever
В то время как TRUE:
# Сгенерируйте случайное значение от 0 до 1
Value = random ()
Print (f ‘. {Значение} ‘)
# блок
Sleep (значение)
# Проверьте, следует ли насильственно закрыть потоку
, если значение> 0,9:
Печать (‘Закрытие потока’)
Sys.exit ()
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# SuperFastPython.com
# пример принудительного закрытия потока с помощью sys.exit
from random import random
от времени импорта времени Sleep
от потока импорта импорта
Import Sys
# Функция задачи
DEF TASCE ():
# Цикл навсегда
В то время как TRUE:
# Создайте случайное значение между 0 и 0 и 1
        value = random()
        print(f’. {value}’)
        # block
        sleep(value)
       0007
, если значение> 0,9:
Print (‘Закрытие потока’)
sys.exit ()
# Создание и настройка новой потоки
Thread = Thread (Target = Task)
# Запустите новый поток thread
thread.start()
# дождаться завершения потока
thread.join()
# main continue on
print(‘Main continue on…’)
При выполнении примера запускается новый поток, затем основной поток блокируется до завершения нового потока.
Новый поток зацикливается навсегда, генерируя и сообщая случайное значение на каждой итерации. Если значение превышает пороговое значение, поток завершается вызовом sys.exit() .
Новый поток завершается, оставляя основной поток для продолжения работы с приложением, например. процесс интерпретатора Python не завершается.
Ниже приведен усеченный пример вывода программы.
Обратите внимание, ваши конкретные результаты будут отличаться из-за использования случайных чисел. Попробуйте запустить пример несколько раз.
1
2
3
4
5
6
7
8
9
…
.0.74942560701
.0.3273867
2105
.0.34153552300063406
.0.24660163964980608
.0.35054226043353376
.0.9501840587444286
Closing thread
Main continuing on…
Теперь давайте посмотрим, как можно закрыть новый поток, вызвав исключение.
Перегружены API параллелизма Python?
Найдите облегчение, загрузите мои БЕСПЛАТНЫЕ интеллектуальные карты Python Concurrency Mind Maps
Закрыть поток, вызвав исключение
Мы можем немедленно закрыть поток Python, вызвав ошибку или исключение , которое не было перехвачено.
Поскольку он не пойман, он распутает граф вызовов из наших пользовательских функций, обратно до run() , затем завершите новый поток.
Обработчик исключений по умолчанию для новых потоков сообщит об исключении на консоль. Это поведение можно изменить, указав функцию обработчика исключений с помощью функции threading.excepthook .
Мы можем обновить пример из предыдущего раздела, чтобы создать исключение Exception для немедленного закрытия потока.
…
# проверить, должны ли мы принудительно закрыть поток
если значение > 0,9:
    print(‘Закрытие потока’)
    raise Exception(‘Остановить сейчас!’)
Обновленная функция task() с этим изменением указана ниже.
1
2
3
4
5
6
7
8
10
110007
12
0002 13
# Функция задачи
DEF TASK ():
# LOOP Forever
В то время как TRUE:
# Сгенерируйте случайное значение от 0 до 1
Value = random ()
Print (f ‘. {Значение} ‘)
# Блок
Sleep (значение)
# Проверьте, следует ли насильственно закрыть потоку
, если значение> 0,9:
Print (‘ закрытие потока ‘)
            поднять исключение(‘Стоп!’)
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# superfastpython.com
# Пример насильственного закрытия потока за исключением
из случайного импорта случайного
от импорта времени Сон
Из потока импорта
Import Sys
# Функция
Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def Def. task():
    # бесконечный цикл
В то время как True:
# Сгенерируйте случайное значение от 0 до 1
value = random ()
print (f ‘. мы должны принудительно закрыть поток
        если значение > 0,9:
            print(‘Closing thread’)
            raise Exception(‘Stop now!’)
# создать новый поток и настроить его0007
thread = Thread(target=task)
# запустить новый поток
thread.start()
# дождаться завершения потока ‘Основное продолжение…’)
При выполнении примера запускается новый поток, затем основной поток блокируется до завершения нового потока.
Новый поток зацикливается навсегда, генерируя и сообщая случайное значение на каждой итерации. Если значение превышает пороговое значение, поток вызывает исключение.
Исключение не перехвачено и поднимается до верхнего уровня потока, которым является функция run() . Затем об исключении сообщается на консоли, и поток завершается.
Затем основной поток продолжает работу с приложением
Ниже приведен усеченный пример вывода программы.
Обратите внимание, ваши конкретные результаты будут отличаться из-за использования случайных чисел. Попробуйте запустить пример несколько раз.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
…
.0.779
38983306
.0.035610159550114484
.0.1607728534728119
.0.29
36735
.0.5331851844899692
.0.8219
2465621
.0.9972997170998285
Closing thread
Исключение в потоке Thread-1:
Трассировка (последний последний вызов):
…
Исключение: Остановить сейчас!
Основное продолжение…
Дополнительная литература
В этом разделе представлены дополнительные ресурсы, которые могут оказаться полезными.
Книги
Python Threading Jump-Start, Джейсон Браунли, 2022 г. ( моя книга! ).
Вопросы для собеседования по Threading API
Памятка API модуля Threading
Я также рекомендую отдельные главы в следующих книгах:
Поваренная книга Python, Дэвид Бизли и Брайан Джонс, 2013.
См.: Глава 12: Параллелизм
Эффективный Python, Бретт Слаткин, 2019 г.
См.: Глава 7: Параллелизм и параллелизм
Python в двух словах, Алекс Мартелли и др., 2017.
См.: Глава: 14: Потоки и процессы
Руководства
Python Threading: полное руководство
API-интерфейсы
многопоточность — параллелизм на основе потоков
Выводы
Теперь вы знаете, как закрыть нить в Python.
Есть вопросы?
Задавайте свои вопросы в комментариях ниже, и я постараюсь ответить.
Photo by Taras Chernus on Unsplash
Как остановить поток в Python
Вы можете остановить поток с помощью threading.Event .
В этом руководстве вы узнаете, как изящно остановить поток в Python .
Начнем.
Содержание
Необходимость остановить поток
Поток — это поток выполнения в компьютерной программе.
Каждая программа Python имеет по крайней мере один поток выполнения, называемый основным потоком. И процессы, и потоки создаются и управляются базовой операционной системой.
Иногда нам может понадобиться создать дополнительные потоки в нашей программе для одновременного выполнения кода.
Python предоставляет возможность создавать новые потоки и управлять ими с помощью модуля threading и класса threading. Thread .
Вы можете узнать больше о потоках Python в руководстве:
Создание потоков в Python: полное руководство
При параллельном программировании мы можем запустить задачу в новом потоке, а затем решить остановить задачу.
Это может быть по многим причинам, например:
Результат задачи больше не требуется.
Приложение закрывается.
Результат задания сбился.
Python не позволяет остановить запущенный поток в API.
Как мы можем остановить поток в Python?
Как остановить поток
Поток можно остановить с помощью общей логической переменной, такой как threading.Событие .
A threading. Событие — это флаг логической переменной потокобезопасности, который может быть установлен или не установлен. Его можно разделить между потоками, проверить и установить, не опасаясь состояния гонки.
Если вы новичок в threading. Events , вы можете узнать больше здесь:
Как использовать объект события в Python
Новое событие может быть создано и затем передано между потоками, например:
…
# создать общее событие
event = Event()
Событие создается в состоянии « не установлено » или Ложь .
Возможно, у нас есть задача в пользовательской функции, которая запускается в новом потоке. Задача может повторяться, например, в цикле while или цикле for.
Например:
# пользовательская функция задачи
def task():
# выполнение задачи в итерациях
пока верно:
# …
Мы можем обновить нашу функцию задачи, чтобы проверять статус события на каждой итерации.
Если событие установлено как true, мы можем выйти из цикла задачи или вернуться из функции task() , что позволит завершить новый поток.
Состояние потока . Событие можно проверить с помощью функции is_set() .
Например:
1
2
3
4
5
6
7
8
# Пользовательская функция задачи
def Task ():
# выполнить задание в итерациях
В то время как True:
# …
# Проверка для остановки
If Event.is_set ():
Break
Основной поток или другой поток может установить событие, чтобы остановить выполнение нового потока.
Событие может быть установлено или создано True с помощью функции set() .
Например:
…
# установить событие
event.set()
# дождаться остановки нового потока
thread.join()
Теперь, когда мы знаем, как остановить поток Python, давайте посмотрим на некоторые рабочие примеры.
Запутался в API модуля потоков?
Загрузите мою БЕСПЛАТНУЮ шпаргалку в формате PDF
Пример остановки потока с помощью пользовательской функции
В этом разделе мы рассмотрим, как остановить поток, выполняющий пользовательскую функцию.
Сначала мы разработаем пример, запускающий пользовательскую функцию в отдельном потоке, а затем посмотрим, как обновить пример, чтобы останавливать поток по требованию.
Пользовательская функция в новом потоке
Мы можем разработать пример, запускающий функцию в новом потоке.
Новая функция задачи будет выполняться в цикле, и после завершения новый поток завершится, а основной поток завершится.
Во-первых, мы можем определить функцию задачи.
Функция выполнит цикл пять раз. Каждую итерацию он будет блокировать на секунду, а затем сообщать о сообщении, чтобы имитировать работу и показать прогресс.
После завершения задачи функция сообщит о последнем сообщении.
Функция task() ниже реализует это.
1
2
3
4
5
6
7
8
9
# пользовательская функция задачи
def Task ():
# выполнить задачу в цикле
для I в диапазоне (5):
# Блок на мгновение
Sleep (1)
# Отчет A message
        print(‘Рабочий поток запущен…’)
    print(‘Рабочий закрывается’)
Затем в основном потоке мы можем создать новый экземпляр threading.Thread , который настроен на выполнение нашей функции task() в новом потоке с помощью аргумента « target ».
…
# создать и настроить новый поток
thread = Thread(target=task)
Затем мы можем немедленно запустить новый поток через start() функция.
…
# запустить новый поток
thread.start()
Затем основной поток будет ждать завершения нового потока, присоединившись к потоку.
Если вы новичок в присоединении к потокам, вы можете узнать больше здесь:
Как присоединиться к потоку в Python
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# SuperFastPython.com
# пример потока, выполняющего пользовательскую функцию
from time import sleep
Из потока импорта потока
# Пользовательская функция задачи
def Task ():
# выполнить задачу в цикле
для I в диапазоне (5):
# Блок на мгновение
( 1)
        # сообщить о сообщении
        print(‘Рабочий поток запущен. ..’)
    print(‘Рабочий процесс закрывается’)

# create and configure a new thread
7
# create and configure a new thread
7
задача)
# запустить новый поток
thread.start()
# дождаться завершения нового потока
thread.join()
Запуск примера сначала создает и запускает новый поток.
Затем основной поток блокируется до завершения нового потока.
Новый поток выполняется в цикле, на мгновение блокируясь и сообщая о ходе выполнения. После пяти итераций цикла новый поток сообщает последнее сообщение и завершается.
Основной поток замечает, что новый поток завершился, и завершает работу, закрывая программу.
1
2
3
4
5
6
Выполняется рабочий поток…
Выполняется рабочий поток…
Выполняется рабочий поток…
Выполняется рабочий поток.. .
Выполняется рабочий поток…
Закрытие рабочего потока
Теперь давайте посмотрим, как мы можем обновить этот пример, чтобы останавливать поток по требованию.
Остановить пользовательскую функцию в новом потоке
Мы можем обновить пример из предыдущего раздела, чтобы остановить новый поток по требованию.
Этого можно добиться, создав новый экземпляр threading.Event , передав его в качестве аргумента новому потоку, а затем обновив пользовательскую функцию, чтобы проверить, устанавливается ли событие на каждой итерации. Как только событие установлено, функция может разорвать свой цикл задачи и выйти, завершив новый поток.
Во-первых, мы можем обновить функцию задачи, чтобы она принимала общий экземпляр threading.Event в качестве аргумента.
# функция пользовательской задачи
def task(event):
# …
Затем мы можем обновить цикл задачи, чтобы проверять состояние события на каждой итерации и, если установлено, разорвать цикл задачи.
…
# проверка остановки
если event.is_set():
    перерыв
Связывая это вместе, обновленная функция task() с этими изменениями указана ниже.
1
2
3
4
5
6
7
8
10
11
12
# функция пользовательской задачи
def task(event):
# выполнить задачу в цикле
для I в диапазоне (5):
# блок на мгновение
Sleep (1)
# Проверка для остановки
If Event.is_set ():
Break
        # сообщить о сообщении
        print(‘Рабочий поток запущен…’)
    print(‘Рабочий процесс закрывается’)
Далее в основном потоке можно сначала создать новый поток . Событие 9Экземпляр 0004 для совместного использования потоками.
…
# создать событие
event = Event()
Затем мы можем обновить основной поток, чтобы он заблокировался на несколько секунд.
…
# заблокировать на время
sleep(3)
Наконец, мы можем установить событие и вызвать остановку нового потока.
…
# остановить рабочий поток
print(‘Главный поток остановки’)
event.set()
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
10
110007
12
13
0007
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# SuperFastPython. com
# пример остановки нового потока
from time import sleep
from threading import Thread
from threading import Event
# Пользовательская функция задачи
DEF Задача (событие):
# выполнить задачу в цикле
для I в диапазоне (5):
# Блок на мгновение
Sleep (1)
# Проверьте, чтобы получить остановку
If Event.is_set ():
Break
# Сообщение о сообщении
Print («Рабочечный поток …»)
Печать («Закрытие работника»)
# создать событие
event = Event()
# создать и настроить новый поток
thread = Thread(target=task, args=(event,))
# запустить новый поток
thread.start ()
# заблокировать на некоторое время
sleep(3)
# остановить рабочий поток
print(‘Основной останавливающий поток’)
event.set()
# дождаться завершения нового потока
thread.join()
Запуск примера сначала создает и запускает новый поток.
Затем основной поток блокируется на несколько секунд.
Тем временем новый поток выполняет свой цикл задач, блокируя и сообщая о сообщении на каждой итерации. Он проверяет событие на каждой итерации, которое остается ложным и не приводит к остановке потока.
Основной поток просыпается, а затем устанавливает событие. Затем он присоединяется к новому потоку, ожидая его завершения.
Поток задач проверяет установленное событие (например, True ). Поток прерывает цикл задачи, сообщает окончательное сообщение, а затем завершает новый поток.
Затем основной поток завершается, закрывая процесс Python.
Работает рабочая нить…
Работает рабочая нить…
Основная стопорная нить
Закрывается рабочая нить
Теперь, когда мы знаем, как остановить выполнение пользовательской функции в новом потоке, давайте рассмотрим пример остановки пользовательского класса потока.
Бесплатный курс Python Threading
Загрузите мою памятку по потоковому API, и в качестве бонуса вы получите БЕСПЛАТНЫЙ доступ к моему 7-дневному электронному курсу.
Узнайте, как использовать модуль Python threading, в том числе как создавать и запускать новые потоки и как использовать мьютексы и семафоры
Подробнее

Пример остановки потока с помощью расширенного класса можно изучить, как остановить поток, который является объектом, расширяющим класс
threading.Thread .
Сначала мы разработаем пример, расширяющий класс threading.Thread , а затем посмотрим, как обновить пример, чтобы останавливать поток по требованию.
Класс Custom Thread
Мы можем запустить задачу в новом потоке, расширив класс threading.Thread и переопределив конструктор и функцию run() .
В этом разделе мы покажем, как запустить ту же задачу, что и в предыдущем разделе, в пользовательском классе потока.
Во-первых, мы можем определить новый класс, расширяющий threading.Thread .
# пользовательский класс потока
класс CustomThread(Thread):
# …
Новый класс должен реализовать конструктор и вызвать конструктор класса threading.Thread , чтобы правильно инициализировать базовый экземпляр потока.
# конструктор
def __init__(self):
    # вызов родительского конструктора
    super(CustomThread, self).__init__()
Затем мы можем переопределить метод run() в классе threading.Thread .
Эта функция будет выполняться в новом потоке, как только поток будет запущен с помощью функции start() . В частности, мы вызываем start() и start() будет вызывать run() для нас в новом потоке исполнения.
Нашей задачей будет пять раз выполнить цикл, заблокировать на секунду для имитации работы и сообщить о сообщении. Затем сообщите сообщение после завершения задачи.
1
2
3
4
5
6
7
8
9
# выполнить задачу
def run(self):
    # выполнить задачу в цикле
для I в диапазоне (5):
# блок на мгновение
Sleep (1)
# Сообщение о сообщении
Print («Рабочечная нить запуска …»)
Print (‘Закрытие работника. )
Связывая это вместе, новый класс CustomThread указан ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Пользовательская потока класс
Класс CustomThread (Thread):
# Конструктор
DEF __init __ (SEFT):
# Вызовите родительский конструктор
Super (CustomThread, Self). выполнить задачу
    def run(self):
        # выполнить задачу в цикле
для I в диапазоне (5):
# Блок на мгновение
Sleep (1)
# Сообщение о сообщении
Печать («Рабочечный поток …»)
Печать («Закрытие работника закрывает ‘)
Далее, в основном потоке, мы можем создать новый экземпляр нашего пользовательского класса потока и запустить его, чтобы выполнить нашу задачу в новом потоке.
…
# создать новый поток
thread = CustomThread()
# запустить новый поток
thread.start()
Затем мы join() создадим новый поток и дождемся его завершения, прежде чем завершить основной поток.
…
# дождаться завершения нового потока
thread.join()
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# SuperFastPython.com
# Пример расширения потока Class
от Import Sleep
из потока импорта потока
# Custom Class Class
Class CustomThread (Thread):
# Convuctor
DEF __init __ (Self):
# Конструктор
DEF __init __ (SEFT):
# Вызовите родительский конструктор
Super (CustomThread, Self) .__ init __ ()
# выполнение задания
def Run (Self):
# выполнить задачу в цикле
для I в диапазоне (5):
# блок на мгновение
Sleep (1)
# Сообщение о сообщении
Print («Рабочечный поток . ..»)
‘)

# создать новый поток
thread = CustomThread()
# запустить новый поток
thread.start()
# дождаться завершения нового потока
thread.join()
При запуске примера сначала создается наш пользовательский класс потока, а затем начинается выполнение нового потока.
Основной поток затем блокируется в ожидании завершения нового потока.
Наш класс пользовательского потока запускает нашу задачу в новом потоке выполнения, зациклив пять раз. Каждую итерацию он блокирует на мгновение, а затем сообщает сообщение.
По завершении задачи выдается заключительное сообщение.
Новый поток завершается, затем основной поток завершается, закрывая процесс.
1
2
3
4
5
6
Выполняется рабочий поток…
Выполняется рабочий поток…
Выполняется рабочий поток. ..
Выполняется рабочий поток…
Выполняется рабочий поток…
Закрытие рабочего потока
Далее давайте посмотрим, как мы можем обновить этот пример, чтобы останавливать задачу по требованию.
Остановить нестандартную резьбу класса
Мы можем обновить пример из предыдущего раздела, чтобы остановить поток по требованию.
Этого можно достичь, разделив событие threading.Event с новым потоком и обновив функцию run() , чтобы проверить, устанавливается ли событие на каждой итерации. После установки функция run() может выйти, что завершит новый поток.
Во-первых, мы можем обновить конструктор нашего нового класса потоков, чтобы он принимал общее threading.Event в качестве аргумента, а затем сохранял его как переменную-член.
1
2
3
4
5
6
# Constructor
def __init __ (Self, Event):
# Call The Parent Constructor
Super (CustomThread, Self) . __ in init __ ()
# Хранить событие
Self.event = Event
Далее мы можем обновить функцию run() , чтобы проверить состояние threading.Event на каждой итерации и прерывание цикла задачи после установки события.
1
2
3
4
5
6
7
8
10
11
12
# выполнить задачу
def run(self):
    # выполнить задачу в цикле
    для i in range(5):
        # заблокировать на мгновение
Sleep (1)
# Проверка для остановки
, если self.event.is_set ():
Break
# Сообщение
Print (‘Trade Worker Trade …’)
Печать (» Рабочий закрывается’)
Связывая это вместе, обновленный класс CustomThread , который можно остановить по требованию, указан ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# класс пользовательского потока
класс CustomThread(Thread):
    # конструктор
    def __init__(self, event):
        # вызов родительского конструктора
Super (CustomThread, Self) .__ init __ ()
# Хранить событие
Self.Event = Event
# выполнение задания
DEF RUN (SEFT):
# Выполнить задание в LOOP
.
для I в диапазоне (5):
# Блок на мгновение
Sleep (1)
# Проверка для остановки
, если Self.event.is_set ():
Break
            # сообщить о сообщении
            print(‘Рабочий поток запущен…’)
        print(‘Рабочий процесс закрывается’)
В основном потоке мы должны сначала создать экземпляр события, который может быть разделен между потоками.
…
# создать событие
event = Event()
Затем мы должны передать его конструктору нашего нового Класс CustomThread .
…
# создать новый поток
thread = CustomThread(event)
Затем мы можем обновить новый поток, чтобы заблокировать его на несколько секунд, а затем запросить завершение нового потока, установив событие.
1
2
3
4
5
6
…
# заблокировать на некоторое время
sleep(3)
# остановить рабочий поток
print(‘Главный останавливающий поток’)
event.set()
Наконец, основной поток будет ждать завершения нового потока.
…
# дождаться завершения нового потока
thread.join()
Связывая это вместе, полный пример приведен ниже.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
0002 31
32
33
34
35
36
37
38
39
40
41
# SuperFastPython.com
# пример остановки класса пользовательского потока
from time import sleep
from threading import Thread
from threading import Event

# custom thread class
(readTh2 # custom thread class
):
# Constructor
def __init __ (Self, Event):
# Позвоните в родительский конструктор
Super (Customthread, Self) . __ init __ ()
# Хранить событие
Self.event = Event
# execute task
    def run(self):
        # выполнение задачи в цикле
        for i in range(5):
             # block for a moment (1) 9 le s 90 0     0007
# Проверка для остановки
, если self.event.is_set ():
Break
# Сообщение о сообщении
Печать («Работающий поток …»)
Print («Закрытие работника»)

# создать событие
event = Event()
# создать новый поток
thread = CustomThread(event)
# запустить новый поток
thread.start()
# заблокировать на некоторое время
sleep(3)
# остановить рабочий поток
print(‘Главный останавливающий поток’)
event.set()
# дождаться завершения нового потока
поток. присоединиться()
Сначала запуск примера включает создание экземпляра пользовательского потока и его запуск.
Затем основной поток блокируется на несколько секунд.
Новый поток начнет выполнение своего цикла задач, на мгновение заблокируется и сообщит о ходе выполнения.
Затем главный поток просыпается и устанавливает событие, вызывая остановку нового потока.
Новый поток замечает, что событие установлено, и затем выходит из цикла задачи, сообщая о последнем сообщении и завершая новый поток.
Основной поток ожидает завершения нового потока, после чего останавливается и закрывает приложение.
Выполняется рабочий поток…
Выполняется рабочий поток…
Основная стопорная резьба
Закрытие рабочего
Перегружены API параллелизма Python?
Найдите облегчение, загрузите мои БЕСПЛАТНЫЕ интеллектуальные карты Python Concurrency Mind Maps
Общие вопросы об остановке потоков
В этом разделе перечислены распространенные вопросы об остановке нового потока в Python.
У вас есть вопросы по поводу остановки новой темы? Дайте мне знать в комментариях, и я сделаю все возможное, чтобы помочь.
Что делать, если в моей задаче нет цикла?
Ваша задача не должна иметь цикл, чтобы быть остановленной.
Вместо этого необходимо добавить частые проверки общего threading.Event и возврат из функции task() или run() после установки события.
Это будет зависеть от специфики задачи, которую вы хотите завершить в новом потоке.
Если ваша задача связана с блокировкой, например, чтением или записью ввода-вывода или ожиданием в другом потоке, вы можете принять ожидание занятости и иметь threading. Событие проверяется на каждой итерации.
Подробнее о реализации ожидания занятости можно узнать здесь:
Как использовать ожидание занятости в Python threading.Event через функцию wait() .
Что делать, если моя задача вызывает исключение?
Если ваша задача, выполняемая в новом потоке, вызывает исключение, которое не обрабатывается, поток завершается.
Это может быть альтернативный способ запуска нового потока для завершения, если это удобно.
Что делать, если мой новый поток уже остановлен?
Если новый поток уже остановлен и вы установили событие, оно не будет иметь никакого эффекта.
Это не проблема.
Что делать, если мой новый поток является потоком демона?
Если ваша задача выполняется в потоке демона, нет необходимости останавливать ее вручную, так как она будет завершена для вас после завершения всех потоков, не являющихся демонами (например, основного потока).
Вы можете узнать больше о потоках демона здесь:
Как использовать потоки демона в Python
Если вы хотите вручную остановить поток демона, вы можете использовать тот же метод, что и выше.
Вы можете увидеть пример этого здесь:
Как изящно остановить поток демона в Python
Как мы можем остановить несколько потоков?
Вы можете разделить одно и то же threading. Event между всеми потоками, которые могут захотеть остановиться.
Каждый поток может часто проверять статус события.
После установки все потоки могут выйти из своей задачи и завершиться.
Как мы можем остановить потоки демона?
Тот же метод использования потоков . Событие можно использовать для остановки потоков демона.
Вы можете увидеть пример этого здесь:
Как изящно остановить поток демона в Python
Как мы можем остановить задачи в ThreadPoolExecutor?
Тот же метод использования threading. Событие можно использовать для остановки выполнения задач в ThreadPoolExecutor .
Вы можете увидеть пример этого здесь:
Как остановить выполнение задач в ThreadPoolExecutor в Python
Дополнительная литература
В этом разделе представлены дополнительные ресурсы, которые могут оказаться полезными.
Книги
Python Threading Jump-Start, Джейсон Браунли, 2022 г. ( моя книга! ).
Threading API Вопросы для собеседования
Памятка по API модуля Threading
Я также рекомендую отдельные главы в следующих книгах:
Поваренная книга Python, Дэвид Бизли и Брайан Джонс, 2013.
См.: Глава 12: Параллелизм
Эффективный Python, Бретт Слаткин, 2019 г.
См.: Глава 7: Параллелизм и параллелизм
Python в двух словах, Алекс Мартелли и др., 2017.
См.: Глава: 14: Потоки и процессы
Руководства
Python Threading: полное руководство
API-интерфейсы
многопоточность — параллелизм на основе потоков
Выводы
Теперь вы знаете, как остановить поток в Python.
Есть вопросы?
Задавайте свои вопросы в комментариях ниже, и я постараюсь ответить.