python---多线程

今天了解了下python中的线程，做下笔记，方便后续回忆

什么是多线程？

多线程简单来说就是指CPU可以同时做多任务，比如CPU可以同时做任务A，也可以做任务B，但是一个CPU的话是不能完全实现并行的，只能实现并发（也就是在多个任务之间快速切换）

在python中如何创建线程？

在python中我们需要使用threading模块中的thread类

查看源码发现其实对于thread类中多线程的使用是用的run这个方法，那么我们可以直接继承thread类，重写run这个方法就可以了

下面是thread类中的init方法和run方法

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)
    def run(self):
        """Method representing the thread's activity.

        You may override this method in a subclass. The standard run() method
        invokes the callable object passed to the object's constructor as the
        target argument, if any, with sequential and keyword arguments taken
        from the args and kwargs arguments, respectively.

        """
        try:
            if self._target:
                self._target(*self._args, **self._kwargs)
        finally:
            # Avoid a refcycle if the thread is running a function with
            # an argument that has a member that points to the thread.
            del self._target, self._args, self._kwargs

在我上传的代码中可以看出在init方法中target参数其实就是传进去的线程，然后将target赋值到了self.target

在run方法中可以看出就是执行的这个线程

所以我们如果需要用到多线程的话直接重写run方法即可

下面来举个栗子：

from threading import Thread


class MyThreading(Thread):
    def run(self):
        for i in range(1000):
            print("-----这是我创建的第一个线程-------")


class MyThreading_2(Thread):
    def run(self):
        for i in range(1000):
            print("-------这是我创建的第二个线程--------")


if __name__ == '__main__':
    a = MyThreading()
    b = MyThreading_2()
    a.start()
    b.start()

上面就实现了两个线程之间并发

------------------------------------------纯属个人理解，如有问题请大家指正-----------------------------------