python小白学习之路--线程

先了解一下并发与并行，它们是两个相似的概念。引用一个比较容易理解的说法，并发是指在一个时间段内发生若干事件的情况，并发是指在同一时刻发生若干事件的情况。

  这个概念可以用单核CPU和多核CPU来理解一下。

  在使用单核CPU时，执行多个任务只能时以并发的方式运行，因为只有一个CPU，所以各个任务会分别占用CPU的一段时间依次执行。如果在自己分得的时间没有完成任务，就会切换到另一个任务，然后在下一次得到CPU使用权的时候再继续执行，直到完成。在这种情况下，因为各个任务的时间段很短、经常切换，所以给我们的感觉就是“同时“进行。

  在使用多核CPU时，每一个核分别运行一个任务，各个核能够同时运行，这是真正的同时运行，也就是并行。

总结一下：CPU小于当前执行的任务数，是假的多任务，也就是并发。CPU大于当前执行的任务数，是真的多任务，也就是并行。

 

  多线程是以并发的方式执行的，也就是说，多个线程并不能真正的同时执行，而是通过线程的快速切换—时间轮换切片。

  线程（thread）是操作系统能够运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

  创建线程的模块有两个，_thread与threading，_thread提供了低级别、原始的线程，它相比于threading模块，功能还是比较有限的，所以我们使用threading模块来学习线程。

  首先创建一个简单的线程，例如，我们跑步时可以一边跑步，一边听歌

import time
import threading


def run():
    for i in range(3):
        print('跑步{}'.format(i))
        time.sleep(1)


def listen_music():
    for i in range(3):
        print('听歌{}'.format(i))
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=run)
    t2 = threading.Thread(target=listen_music)
    t1.start()
    t2.start()

  运行结果：

  跑步0
  听歌0
  听歌1
  跑步1
  跑步2
  听歌2

  这样运行起来看上去跑步与听歌就是同步进行的。

提示：子线程的创建不是由threading.Thread()出来的，而是由t.start()创建的和启动

  

  t1与t2是主线程，run和listen_music这两个函数是子线程，从上面可以看出先执行的是主线程，然后由主线程调用子线程执行，并且主线程运行运行完毕后，子线程不会停止，会继续执行完子线程才会结束。

  我们也可以执行完主线程直接结束，不等待子线程，叫做防守线程，也叫做守护线程

  使用方法：t.setDaemon(True)

  示例：

  

import time
import threading


def run():
    for i in range(3):
        print('跑步{}'.format(i))
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=run)
    t1.setDaemon(True)
    t1.start()

    print('hello world')

  运行结果：

  跑步0
  hello world

 

那是否可以实现子线程结束完毕，其他主线程才继续执行呢？

  使用方法：t.join()

示例：

import time
import threading


def run():
    for i in range(3):
        print('跑步{}'.format(i))
        time.sleep(1)


if __name__ == '__main__':
    t1 = threading.Thread(target=run)

    t1.start()
    t1.join()
    print('hello world')

输出结果：

跑步0
跑步1
跑步2
hello world

 

查看当前执行的线程数量：

使用方法：threading.enumerate()

示例：

import time
import threading


def demo1():
    for i in range(3):
        print(f"-----demo1------{i}")
        time.sleep(1)


def demo2():
    for i in range(3):
        print(f"-----demo2------{i}")
        time.sleep(1)


def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    t2.start()

    while True:
        print(threading.enumerate())
        if len(threading.enumerate()) <= 1:
            break
        time.sleep(1)


if __name__ == '__main__':
    main()

输出结果：

-----demo1------0
-----demo2------0[<_MainThread(MainThread, started 11372)>, <Thread(Thread-1, started 12704)>, <Thread(Thread-2, started 6532)>]

-----demo1------1[<_MainThread(MainThread, started 11372)>, <Thread(Thread-1, started 12704)>, <Thread(Thread-2, started 6532)>]

-----demo2------1
[<_MainThread(MainThread, started 11372)>, <Thread(Thread-1, started 12704)>, <Thread(Thread-2, started 6532)>]
-----demo1------2
-----demo2------2
[<_MainThread(MainThread, started 11372)>, <Thread(Thread-1, started 12704)>, <Thread(Thread-2, started 6532)>]
[<_MainThread(MainThread, started 11372)>]

从上面的结果可以看出，线程打印是没有顺序的，存在线程间抢占资源。开始打印的是三个线程，两个子线程，一个主线程，最后子线程执行完，只剩一个主线程。

 

 

继承threading.Thread类创建线程

示例：

import time
import threading


class A(threading.Thread):

    # 重写run方法，方法名必须是run
    def run(self):
        for i in range(3):
            print(f"-----{i}------")
            self.demo()
            time.sleep(1)

    # 如果类中有其它方法实现线程，在run方法中调用
    def demo(self):
        print("-----demo-------")


if __name__ == '__main__':
    a = A()
    a.start()

输出结果：

-----0------
-----demo-------
-----1------
-----demo-------
-----2------
-----demo-------