业务代码耗时操作优化

用户4945346

发布于 2020-06-16 10:00:25

6780

发布于 2020-06-16 10:00:25

前几天我把我们小程序登录接口性能优化了，优化之前登录接口响应时间大概是 300 ms 左右，优化后的响应时间大概在 70 ms 左右。我们小程序登录接口涉及到的业务操作除了基本的登录验证功能外还加了个用户小程序openid的获取和保存操作。我为每个功能都用 time 方法打印了各自操作的耗时，通过比对耗时发现是获取用户 openid 的操作比较耗时，因为涉及到了向微信发送 request 的请求以及等待微信的请求响应，所有我就把获取用户 openid 这块用异步方法实现，借助的模块是 threading 中 Timer 类。

先看下 Time 简单使用

import time
from threading import Timer

def test_timer():
    print("start=======")
    t1 = time.time()
    time.sleep(3)
    print("ok")
    t2 = time.time()
    t21 = t2 - t1
    print('t21====', t21)

def async_test_timer():
    Timer(1, test_timer, []).start()

if __name__ == "__main__":
    tm1 = time.time()
    time.sleep(1)
    async_test_timer()
    tm2 = time.time()
    tm21 = tm2 - tm1
    print('tm21=====', tm21)

上面代码的执行结果为:

tm21===== 1.0052900314331055
start=======
ok
t21==== 3.0050549507141113

上面的代码是先打印了 tm21 ，然后再执行了 async_test_timer 函数，Timer 类表示一个动作应该在一个特定的时间之后运行 — 也就是一个计时器。Timer是Thread的子类，因此也可以使用函数创建自定义线程。它是异步的，用它处理耗时的操作很方便。第一个参数是多少秒后执行，第二个参数是函数名，第三个参数是要异步执行的函数所需的参数。

下面附 Timer 类的源码，它继承了 Thread 类。

class Timer(Thread):
    """Call a function after a specified number of seconds:

            t = Timer(30.0, f, args=None, kwargs=None)
            t.start()
            t.cancel()     # stop the timer's action if it's still waiting

    """

    def __init__(self, interval, function, args=None, kwargs=None):
        Thread.__init__(self)
        self.interval = interval
        self.function = function
        self.args = args if args is not None else []
        self.kwargs = kwargs if kwargs is not None else {}
        self.finished = Event()


class Thread:
    """A class that represents a thread of control.

    This class can be safely subclassed in a limited fashion. There are two ways
    to specify the activity: by passing a callable object to the constructor, or
    by overriding the run() method in a subclass.

    """

    _initialized = False
    # Need to store a reference to sys.exc_info for printing
    # out exceptions when a thread tries to use a global var. during interp.
    # shutdown and thus raises an exception about trying to perform some
    # operation on/with a NoneType
    _exc_info = _sys.exc_info
    # Keep sys.exc_clear too to clear the exception just before
    # allowing .join() to return.
    #XXX __exc_clear = _sys.exc_clear

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None):
        """This constructor should always be called with keyword arguments. Arguments are:

        *group* should be None; reserved for future extension when a ThreadGroup
        class is implemented.

        *target* is the callable object to be invoked by the run()
        method. Defaults to None, meaning nothing is called.

        *name* is the thread name. By default, a unique name is constructed of
        the form "Thread-N" where N is a small decimal number.

        *args* is the argument tuple for the target invocation. Defaults to ().

        *kwargs* is a dictionary of keyword arguments for the target
        invocation. Defaults to {}.

        If a subclass overrides the constructor, it must make sure to invoke
        the base class constructor (Thread.__init__()) before doing anything
        else to the thread.

        """
        assert group is None, "group argument must be None for now"
        if kwargs is None:
            kwargs = {}
        self._target = target
        self._name = str(name or _newname())
        self._args = args
        self._kwargs = kwargs
        if daemon is not None:
            self._daemonic = daemon
        else:
            self._daemonic = current_thread().daemon
        self._ident = None
        self._tstate_lock = None
        self._started = Event()
        self._is_stopped = False
        self._initialized = True
        # sys.stderr is not stored in the class like
        # sys.exc_info since it can be changed between instances
        self._stderr = _sys.stderr
        # For debugging and _after_fork()
        _dangling.add(self)