IT博客-魔のkyo的工作室-随笔分类-Python

解决matplotlib中文乱码

魔のkyo — Wed, 25 Aug 2021 09:25:00 GMT

import matplotlib.pyplot as plt
plt.rcParams["font.sans-serif"]=["SimHei"]
plt.rcParams["axes.unicode_minus"]=False

魔のkyo 2021-08-25 17:25 发表评论

Python实现滚动数组，Python特殊方法的使用，Python运算符重载

魔のkyo — Mon, 07 Sep 2020 07:48:00 GMT

# -*- coding: utf-8 -*-

class RollArray:
    class Iterator:
        def __init__(self, subject):
            self.subject = subject
            self.start = self.subject.idx
            self.i = 0

        def __next__(self):
            while self.i < self.subject.capability:
                if self.start + self.i in self.subject:
                    o = self.subject[self.start + self.i]
                    self.i += 1
                    return o
                else:
                    self.i += 1
            raise StopIteration()

    def __init__(self, capability, items=[]):
        self.data = [None] * capability
        self.used = [False] * capability
        self.idx = 0
        self.capability = capability
        for e in items:
            self.append(e)

    def append(self, obj):
        self.data[self.idx] = obj
        self.used[self.idx] = True
        self.idx = (self.idx + 1) % 10

    # 重载 for e in x:
    def __iter__(self):
        return RollArray.Iterator(self)

    # 重载 [] const
    def __getitem__(self, i):
        if self.used[i%self.capability]:
            return self.data[i%self.capability]
        else:
            raise IndexError()

    # 重载 []
    def __setitem__(self, i, v):
        self.data[i%self.capability] = v
        self.used[i%self.capability] = True
        return v

    # 重载 del x[]
    def __delitem__(self, i):
        self.used[i%self.capability] = False

    # 重载 if e in x:
    def __contains__(self, i):
        return self.used[i%self.capability]

    def tolist(self):
        l = []
        for e in self:
            l.append(e)
        return l

    def __repr__(self):
        return f"{self.__class__.__name__}({self.capability}, items={self.tolist()})"

if __name__ == '__main__':
    arr = RollArray(10, range(5))
    del arr[3]
    print(arr)

    for i in range(5, 11):
        arr.append(i)

    print(arr)

    arr[11] = 11
    print(arr)

    for e in arr:
        print(e)

魔のkyo 2020-09-07 15:48 发表评论

使用flask和flask_restful搭建Restful Web Service的模板

魔のkyo — Wed, 25 Mar 2020 10:51:00 GMT

# -*- coding: utf-8 -*-
import datetime
import time
from flask import Flask as _Flask
from flask import request, jsonify as _jsonify
from flask.json import JSONEncoder as _JSONEncoder
from flask_restful import Api, Resource

# 处理自定义数据类型的JSON编码
class JSONEncoder(_JSONEncoder):
    def default(self, o):
        if hasattr(o, 'keys') and hasattr(o, '__getitem__'):
            return dict(o)
        if isinstance(o, datetime.datetime):
            return o.strftime('%Y-%m-%d %H:%M:%S')
        if isinstance(o, datetime.date):
            return o.strftime('%Y-%m-%d')
        if isinstance(o, datetime.time):
            return o.strftime('%H:%M:%S')
        if isinstance(o, Exception):
            return str(o)
        return super(JSONEncoder, self).default(o)

# 改进jsonify，支持传入HTTP状态码和HTTP头
def jsonify(data_or_tuple, status_code=None, headers=None):
    if type(data_or_tuple) == tuple and not status_code and not headers:
        return jsonify(*data_or_tuple)
    rsp = _jsonify(data_or_tuple)
    if status_code:
        rsp.status_code = status_code
    if headers:
        for k, v in headers.items():
            rsp.headers[k] = v
    rsp.headers["Access-Control-Allow-Origin"] = "*"  # 允许跨域访问
    return rsp

# 继承原始的Flask为了替换其中的JSONEncoder
class Flask(_Flask):
    json_encoder = JSONEncoder

app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False  # 关闭返回JSON数据时根据KEY的字母序重新排序
api = Api(app)

class IndexResource(Resource):
    def get(self):  # 方法名即http method
        obj = {
            "str": "Hello world.",
            "now": datetime.datetime.now()
        }
        return jsonify({"result_code": "success", "data": obj}, 200)
api.add_resource(IndexResource, "/")  # 绑定主页URL到IndexResource类

class UserResource(Resource):
    def get(self, name):
        if 1 <= len(name) <= 10:
            obj = {
                "str": f"Hello, {name}.",
                "now": datetime.datetime.now()
            }
            return jsonify({"result_code": "success", "data": obj}, 200)
        else:
            return jsonify({"result_code": "fail", "err_code": "INVALID_PARAM", "err_code_des": "name非法"}, 401)

    def put(self, name):
        pass

    def delete(self, name):
        pass

api.add_resource(UserResource, "/users/")

class UsersResource(Resource):
    # 使用 http://127.0.0.1:30101/users/ POST 访问
    # RequestBody: {"name":"daimingzhuang"}
    # 记得添加header: Content-Type : application/json
    def post(self):
        body_obj = request.get_json()
        print(body_obj)
        return jsonify({"result_code": "success", "data": body_obj}, 200)
api.add_resource(UsersResource, "/users/")

# 生产环境通过gunicorn启动
# 使用 pip3 install gunicorn 安装 gunicorn
# gunicorn -b : :
# 例如: gunicorn -b 0.0.0.0:30101 app:app
if __name__ == '__main__':
    SERVER_PORT = 30101
    app.run(debug=True, host='0.0.0.0', port=SERVER_PORT)

魔のkyo 2020-03-25 18:51 发表评论

Python中监视线程卡死并自动崩溃退出 WatchDog

魔のkyo — Tue, 17 Mar 2020 07:32:00 GMT

监视主线程卡死，发现时进行处理，例如保错再主动崩溃退出，这样再结合监视崩溃自动重启就可以在卡死时实现自动重启。

import threading
import traceback
import time
import sys
import os
from functools import wraps
# from .logger import logger

class WatchDog(threading.Thread):

    def __init__(self, timeout=10, echo=False):
        super(WatchDog, self).__init__()
        self.timeout = timeout
        self.echo = echo
        self.last_kicked_ts = time.time()
        self.lock = threading.Lock()
        self.thread_id = threading.currentThread().ident
        self.terminated = False
        self.setDaemon(True)
        self.start()

    def terminate(self):
        self.terminated = True
        self.join(self.timeout)

    def kick(self):
        self.lock.acquire()
        self.last_kicked_ts = time.time()
        self.lock.release()

    def bark(self):
        formated_frame_stack = self._get_formated_frame_stack()
        if self.echo:
            print("!!!!! WATCH DOG FAILURE TRIGGERED !!!!!\n" + formated_frame_stack)
        # logger.fatal("!!!!! WATCH DOG FAILURE TRIGGERED !!!!!\n" + formated_frame_stack)
        pid = os.getpid()
        os.kill(pid, 2) # 通知进程退出
        time.sleep(5)   # 等待5秒
        os.kill(pid, 9) # 发送强制退出

    def run(self):
        while not self.terminated:
            ts = time.time()
            self.lock.acquire()
            is_timeout = ts - self.last_kicked_ts > self.timeout
            self.lock.release()
            if is_timeout:
                self.bark()
            n = int(max(self.timeout / 3, 1))
            for i in range(n*10):
                time.sleep(0.1)
                if self.terminated:
                    break

    @staticmethod
    def _get_thread(tid):
        for t in threading.enumerate():
            if t.ident == tid:
                return t
        return None

    @staticmethod
    def _get_frame_stack(tid):
        for thread_id, stack in sys._current_frames().items():
            if thread_id == tid:
                return stack
        return None

    def _get_formated_frame_stack(self):
        info = []
        th = self._get_thread(self.thread_id)
        stack = self._get_frame_stack(self.thread_id)
        info.append('%s thead_id=%d' % (th.name, self.thread_id))
        for filename, lineno, _, line in traceback.extract_stack(stack):
            info.append('    at %s(%s:%d)' % (line, filename[filename.rfind(os.path.sep) + 1:], lineno))
        return '\n'.join(info)

def watch_dog(timeout=10, echo=False):
    def inner(func):
        def wrapper(*args, **kw):
            dog = WatchDog(timeout=timeout, echo=echo)
            ret = func(*args, **kw)
            dog.terminate()
            return ret
        return wrapper
    return inner

用法：

dog = WatchDog(echo=True)
while True:
consumer.workex(timeout_ms=100)
dog.kick()

魔のkyo 2020-03-17 15:32 发表评论

解决pandas打印DataFrame显示不全

魔のkyo — Mon, 24 Feb 2020 12:27:00 GMT

def float_format(x):
    if abs(x) >= 1e10 or 0 < abs(x) < 1e-3:
        return "%e" % x
    else:
        return "%.4f" % x

def pandas_pretty_printing():
    pd.set_option('display.max_rows', None)     # 解决行显示不全
    pd.set_option('display.max_columns', None)  # 解决列显示不全
    pd.set_option('max_colwidth', 1000)         # 解决列宽不够
    pd.set_option('display.width', 1000)         # 解决列过早换行
    pd.set_option('display.float_format', float_format)  # 解决浮点数总是科学计数法

魔のkyo 2020-02-24 20:27 发表评论

Python实现的一个消息总线+计划任务 Driver

魔のkyo — Tue, 21 Jan 2020 06:28:00 GMT

import threading
import time
import queue
from dataclasses import dataclass, field
from typing import Any

@dataclass(order=True)
class ScheduledItem:
    time_sec: float
    cb: Any = field(compare=False)

class Driver:
    def __init__(self):
        self.scheduled = queue.PriorityQueue()
        self.scheduled_every_lock = threading.Lock()
        self.scheduled_every = []
        self.callbacks_lock = threading.Lock()
        self.callbacks = {}
        self.async_queue = queue.Queue()
        self.epoch_sec = time.time()
        self.last_epoch = None

    # 得到driver内的当前时间秒数
    def get_epoch(self):
        return self.epoch_sec

    # 执行一趟主逻辑，一般放在主循环中执行
    def run(self, wait_sync_interval=0):
        self.epoch_sec = time.time()

        if self.last_epoch is not None:
            if self.epoch_sec - self.last_epoch < wait_sync_interval:
                t = wait_sync_interval - (self.epoch_sec - self.last_epoch)
                time.sleep(t)
                self.epoch_sec = time.time()
        self.last_epoch = self.epoch_sec

        self._do_async()
        self._do_schedule()
        self._do_schedule_every()

    # 计划单次定时任务
    def schedule(self, cb, time_sec):
        self.scheduled.put_nowait( ScheduledItem(time_sec, cb) )

    # 计划重复任务
    def schedule_every(self, cb, interval_sec):
        self.scheduled_every_lock.acquire()
        self.scheduled_every.append( { "next_sec":self.epoch_sec+interval_sec, "interval":interval_sec, "cb":cb } )
        self.scheduled_every_lock.release()

    # 增加消息接收者
    def add_receiver(self, topic_or_type, cb):
        self.callbacks_lock.acquire()
        if topic_or_type not in self.callbacks:
            self.callbacks[topic_or_type] = set()
        self.callbacks[topic_or_type].add(cb)
        self.callbacks_lock.release()
        return cb

    # 删除消息接收者
    def remove_receiver(self, topic_or_type, cb):
        self.callbacks_lock.acquire()
        if topic_or_type in self.callbacks:
            if cb in self.callbacks[topic_or_type]:
                self.callbacks[topic_or_type].remove(cb)
        self.callbacks_lock.release()

    # 同步发送消息
    def send(self, obj, topic=None):
        if topic == None:
            topic = type(obj)
        cbs = []
        self.callbacks_lock.acquire()
        if topic in self.callbacks.keys():
            cbs = list(self.callbacks[topic])
        self.callbacks_lock.release()
        for cb in cbs:
            cb(obj)

    # 异步发送消息
    def send_async(self, obj, topic=None):
        self.async_queue.put_nowait( (obj, topic) )

    def _do_async(self):
        while not self.async_queue.empty():
            self.send(*self.async_queue.get_nowait())

    def _do_schedule(self):
        i = 0
        while not self.scheduled.empty():
            item = self.scheduled.get_nowait()
            if item.time_sec > self.epoch_sec:
                self.scheduled.put_nowait(item)
                break
            item.cb(self.epoch_sec)

    def _do_schedule_every(self):
        cbs = []
        self.scheduled_every_lock.acquire()
        for o in self.scheduled_every:
            while self.epoch_sec >= o["next_sec"]:
                cbs.append(o["cb"])
                o["next_sec"] += o["interval"]
        self.scheduled_every_lock.release()
        for cb in cbs:
            cb(self.epoch_sec)

def bind(func, *args, **kw):
    return lambda *_args, **_kw: func(*args, *_args, **kw, **_kw)

driver = Driver()

魔のkyo 2020-01-21 14:28 发表评论

基于Redis的分布式Mutex, ReadWriteLock

魔のkyo — Wed, 15 Jan 2020 05:39:00 GMT

# -*- coding: utf-8 -*-
from redis import ConnectionPool
import redis
import time
import uuid

POOL = ConnectionPool(host='127.0.0.1', max_connections=100)

class Redis(redis.Redis):
    def __init__(self, host=None):
        global POOL
        if POOL.connection_kwargs["host"] != host:
            POOL = ConnectionPool(host=host, max_connections=100)
        super().__init__(connection_pool=POOL)

# 互斥锁
class Mutex:
    def __init__(self, name, server="127.0.0.1"):
        self.name = name
        self.key_name = "MUTEX_" + name
        self.id = uuid.uuid4().hex
        self.redis = Redis(host=server)

    def acquire(self, blocking=True, ex=30):
        r = self.redis.set(self.key_name, self.id, ex=ex, nx=True)
        if blocking:
            while not r:
                time.sleep(0.01)
                r = self.redis.set(self.key_name, self.id, ex=ex, nx=True)
        return r

    def release(self):
        if self.acquired():
            self.redis.delete(self.key_name)

    def acquired(self):
        r = self.redis.get(self.key_name)
        return r != None and r.decode() == str(self.id)

    def __enter__(self):
        self.acquire()

    def __exit__(self, exc_type, exc_value, exc_trackback):
        self.release()
        if exc_value != None:
            raise exc_value

# 读写锁
class ReadWriteLock:
    def __init__(self, name, server="127.0.0.1"):
        self.name = name
        self.server = server
        self.rlock_name = "RLOCK_" + name
        self.wlock_name = "WLOCK_" + name
        self.id = uuid.uuid4().hex
        self.redis = Redis(host=server)
        self.lock_type = None

    def read_lock(self, blocking=True, ex=30):
        mutex = Mutex(self.name, self.server)
        try:
            mutex.acquire()
            wlock_locked = self.redis.get(self.wlock_name)
            if wlock_locked:
                if blocking:
                    while wlock_locked:
                        mutex.release()
                        time.sleep(0.05)
                        mutex.acquire()
                        wlock_locked = self.redis.get(self.wlock_name)
                else:
                    return False

            pipeline = self.redis.pipeline()
            now = time.time()
            pipeline.zremrangebyscore(self.rlock_name, 0, int((now-ex)*1000) )
            pipeline.zadd(self.rlock_name, {self.id: int(now*1000)} )
            pipeline.expire(self.rlock_name, ex)
            pipeline.execute()
            self.lock_type = 'R'
            return True
        except Exception as e:
            raise
        finally:
            mutex.release()

    def write_lock(self, blocking=True, ex=30):
        mutex = Mutex(self.name, self.server)
        try:
            mutex.acquire()
            self.redis.zremrangebyscore(self.rlock_name, 0, int((time.time()-ex)*1000) )
            r = self.redis.zcard(self.rlock_name)
            if r:
                if blocking:
                    while r:
                        mutex.release()
                        time.sleep(0.05)
                        mutex.acquire()
                        self.redis.zremrangebyscore(self.rlock_name, 0, int((time.time()-ex)*1000) )
                        r = self.redis.zcard(self.rlock_name)
                else:
                    return False
            r = self.redis.set(self.wlock_name, self.id, ex=ex, nx=True)
            if blocking:
                while not r:
                    mutex.release()
                    time.sleep(0.05)
                    mutex.acquire()
                    r = self.redis.set(self.wlock_name, self.id, ex=ex, nx=True)
            if r:
                self.lock_type = 'W'
            return r
        except Exception as e:
            raise
        finally:
            mutex.release()

    def unlock(self):
        if self.lock_type == 'R':
            self.redis.zrem(self.rlock_name, self.id)
            self.lock_type = None
        elif self.lock_type == 'W':
            r = self.redis.get(self.wlock_name)
            if r != None and r.decode() == str(self.id):
                self.redis.delete(self.wlock_name)
            self.lock_type = None

考虑了锁住后崩溃，解决方案是超时后自动结束。
考虑了未崩溃但是超时（这种情况首先考虑默认超时时间是否应该调整，或者程序是否需要调整锁住的代码分多次锁？）。
在这种异常情况发生时，可能产生一边释放了锁但还在访问，另一边加上了锁，记住这时异常情况，但我们要保证即使它发生了也尽量能正常工作下去，
对于确实存在访问冲突的那么是没办法的，该异常就异常好了，还有种情况是虽然加了锁，但是并没有访问冲突，其实程序可以正常下去，但是这里会发生什么呢？
对于A线程，手动加锁----------超时自动解锁|------------------------手动解锁|
对于B线程，-------------手动加锁-----------|（等到此加锁成功）------------|---------手动解锁
对于C线程，---------------------------------|------------手动加锁------------|（等到此加锁成功）
A线程因为超时自动解锁后虽然和B线程没有发生访问冲突，但是它解了B线程的锁，导致C线程加锁成功，而B线程实际还没解锁，这又制造了潜在的B线程和C线程的访问冲突。
所以手动解锁时应该判断下当前的锁是否是自己加的。
支持阻塞和非阻塞加锁，默认阻塞，非阻塞用法
if lock.acquire(blocking=False):
pass
判断加锁成功在做一些事，一些其他语言里命名为tryLock方法。

魔のkyo 2020-01-15 13:39 发表评论

Python SQLAlchemy的ORM模块用例，多数据库连接封装

魔のkyo — Tue, 07 Jan 2020 03:05:00 GMT

摘要: db.pyCode highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--># -*- coding: utf-8 -*-from sqlalchemy import Table, Colu... 阅读全文

魔のkyo 2020-01-07 11:05 发表评论

Python使用msgpack对任意单层POD类型class编解码

魔のkyo — Tue, 19 Nov 2019 16:00:00 GMT

import msgpack

def obj_dict_serializer(obj):
    return msgpack.dumps(vars(obj))

def obj_dict_deserializer(T):
    def deserializer(buf):
        obj = T()
        dic = msgpack.unpackb(buf)
        for k,v in dic.items():
            k = k.decode()
            if type(v)==bytes:
                v = v.decode()
            setattr(obj, k, v)
        return obj
    return deserializer

def obj_list_serializer(obj):
    return msgpack.dumps(list(vars(obj).values()))

def obj_list_deserializer(T):
    def deserializer(buf):
        obj = T()
        for k, v in zip(vars(obj).keys(), msgpack.unpackb(buf)):
            if type(v)==bytes:
                v = v.decode()
            setattr(obj, k, v)
        return obj
    return deserializer

if __name__ == '__main__':
    from dataclasses import dataclass
    @dataclass
    class Stu:
        id : int = 0
        name: str = ""
        stuno: str = ""

    stu1 = Stu(1, "张三", "190003160")
    stu2 = Stu(2, "李四", "190003161")

    buf1 = obj_dict_serializer(stu1)
    stu1_ = obj_dict_deserializer(Stu)(buf1)
    print(stu1, stu1_)
    print(stu1 == stu1_)

    buf2 = obj_dict_serializer(stu2)
    stu2_ = obj_dict_deserializer(Stu)(buf2)
    print(stu2, stu2_)
    print(stu2 == stu2_)

配合在C++上使用msgpack.hpp 像class、struct中添加 MSGPACK_DEFINE 或 MSGPACK_DEFINE_MAP，可以实现python和C++之间的数据互传后的编解码

魔のkyo 2019-11-20 00:00 发表评论

Python虚拟环境virtualenv

魔のkyo — Sun, 17 Nov 2019 06:07:00 GMT

安装

pip3 install virtualenv
pip3 install virtualenvwrapper

修改用户家目录下的配置文件.bashrc，添加如下内容：

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
source /usr/local/bin/virtualenvwrapper.sh

执行.bashrc，让修改立即生效

source ~/.bashrc

创建虚拟环境

mkvirtualenv <环境名>

进入虚拟环境

workon <环境名>

从虚拟环境中退出

deactivate

删除虚拟环境

rmvirtualenv <环境名>

导出当前环境已安装的包

pip freeze > requirements.txt

安装包列表

pip install [-i https://指定安装源] -r requirements.txt

国内可选安装源地址：

阿里云 http://mirrors.aliyun.com/pypi/simple/

清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/

永久更换安装源

编辑 ~/.pip/pip.conf

## Note, this file is written by cloud-init on first boot of an instance
## modifications made here will not survive a re-bundle.
###
[global]
index-url=http://mirrors.cloud.aliyuncs.com/pypi/simple/

[install]
trusted-host=mirrors.cloud.aliyuncs.com

魔のkyo 2019-11-17 14:07 发表评论

Python中设置Thread超时(Timeout)结束或主动杀死(Kill)

魔のkyo — Sat, 16 Nov 2019 13:51:00 GMT

先上正确的代码

参考 https://blog.csdn.net/vinsuan1993/article/details/78158589/

import threading
import time
import inspect
import ctypes

class KillableThread(threading.Thread):
    def __init__(self, *args, **kw):
        super(KillableThread, self).__init__(*args, **kw)

    def _async_raise(tid, exctype):
        """raises the exception, performs cleanup if needed"""
        tid = ctypes.c_long(tid)
        if not inspect.isclass(exctype):
            exctype = type(exctype)
        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
        if res == 0:
            raise ValueError("invalid thread id")
        elif res != 1:
            # """if it returns a number greater than one, you're in trouble,
            # and you should call it again with exc=NULL to revert the effect"""
            ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
            raise SystemError("PyThreadState_SetAsyncExc failed")

    def kill(self):
        KillableThread._async_raise(self.ident, SystemExit)

# 循环输出s，t次，每0.6秒一次
def say(s,t):
    for i in range(t):
        print(s)
        time.sleep(0.6)

if __name__ == "__main__":
    thread1 = KillableThread(target=say, args=("Say 3 times", 3))
    thread1.start()
    thread1.join()
    print("Alive? ", thread1.is_alive())
    thread2 = KillableThread(target=say, args=("Say 999 times", 999))
    thread2.start()
    thread2.join(2)
    print("Alive? ", thread2.is_alive())
    thread2.kill()
    print("Still alive? ", thread2.is_alive())
    # 查看线程数量
    while True:
        thread_num = len(threading.enumerate())
        print("线程数量是%d" % thread_num)
        if thread_num <= 1:
            break
        time.sleep(1)
    print("Still alive? ", thread2.is_alive())

输出为

Say 3 times
Say 3 times
Say 3 times
Alive? False
Say 999 times
Say 999 times
Say 999 times
Say 999 times
Alive? True
Still alive? True
线程数量是2
线程数量是1
Still alive? False

------ 分割线以下分析是错的 ------

后面的代码是错误的，错误在于setDaemon是让被设置的线程随主线程一起结束，而不是父线程，我不清楚这样有什么意义。之所以没有发现下面代码是错的，是因为正好主线程后面就结束了，如果让主线程继续空转就会看到999那个线程还在输出

Python中的threading.Thread并没有提供kill方法杀死尚未结束的线程，但是提供了setDaemon方法设置守护线程，守护线程会在父线程结束时自动结束。

注意父线程是调用线程start()的线程，而不是创建threading.Thread对象的线程，下面的代码演示了通过setDaemon方法让线程超时自动结束。

import threading
import time

def start_thread_with_timeout(target, secs:int, args=None):
    th = threading.Thread(target=target, args=args)
    timeout = True
    def daemon_thread():
        '''
        对于嵌套定义的函数，当Python发现读取一个不存在的变量时，
        会向外层去找，而当给一个变量赋值时，若函数内不存在此变量，
        优先创建而不向外找，所以此处timeout必须声明为nonlocal，
        而对th的声明是可选的
        '''
        # 声明外部变量
        nonlocal timeout, th
        th.setDaemon(True) # 设置为守护线程，会在它的父线程结束时自动结束
        th.start()
        th.join(secs)
        timeout = th.is_alive()
    guard = threading.Thread(target=daemon_thread)
    guard.start()
    guard.join()
    return timeout

# 循环输出s，t次，每0.6秒一次
def say(s,t):
    for i in range(t):
        print(s)
        time.sleep(0.6)

if __name__ == "__main__":
    # 输出字符串3次，每次间隔0.6s，2s后超时，所以此处应该不会超时结束
    timeout = start_thread_with_timeout(target=say, args=("Say 3 times", 3), secs=2)
    print("Timeout? ", timeout)
    # 输出字符串999次，每次间隔0.6s，2s后超时，所以此处应该不会超时结束
    timeout = start_thread_with_timeout(target=say, args=("Say 999 times", 999), secs=2)
    print("Timeout? ", timeout)

程序输出为：

Say 3 times
Say 3 times
Say 3 times
Timeout? False
Say 999 times
Say 999 times
Say 999 times
Say 999 times
Timeout? True

清楚原理后也可以用来实现kill的功能，例如可以让哨兵线程每隔一个时间片查询一次需要kill的flag，不过这样没有办法实时杀死线程，时间片设太大就延迟杀死，设太小会频繁占用CPU，解决方法可以通过信号量(semaphore)或者条件变量(condition)让哨兵线程陷入睡眠，外部调用kill唤醒哨兵线程直接结束就可以了。
（哨兵线程：守卫线程的父线程，可以看做是真正要执行的线程的哨兵，所以我称之为哨兵线程）

import threading
import time

class KillableThread:
    def __init__(self, target, args=None):
        self.th = threading.Thread(target=target, args=args)
        self.kill_sema = threading.Semaphore(0)
        self.start_sema = threading.Semaphore(0)
        def daemon_thread(self):
            self.th.setDaemon(True)
            self.th.start()
            self.start_sema.release()
            self.kill_sema.acquire()
        self.guard = threading.Thread(target=daemon_thread, args=(self,))

    def start(self):
        self.guard.start()
        self.start_sema.acquire()

    def join(self, secs=None):
        self.th.join(secs)
        if not self.th.is_alive():
            self.kill_sema.release()

    def is_alive(self):
        return self.th.is_alive() and self.guard.is_alive()

    def kill(self):
        self.kill_sema.release()
        while self.guard.is_alive():
            pass


# 循环输出s，t次，每0.6秒一次
def say(s,t):
    for i in range(t):
        print(s)
        time.sleep(0.6)

if __name__ == "__main__":
    thread1 = KillableThread(target=say, args=("Say 3 times", 3))
    thread1.start()
    thread1.join()
    print("Alive? ", thread1.is_alive())
    thread2 = KillableThread(target=say, args=("Say 999 times", 999))
    thread2.start()
    thread2.join(2)
    print("Alive? ", thread2.is_alive())
    thread2.kill()
    print("Still alive? ", thread2.is_alive())

魔のkyo 2019-11-16 21:51 发表评论