多线程

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程

线程顾名思义，就是一条流水线工作的过程（流水线的工作需要电源，电源就相当于cpu），而一条流水线必须属于一个车间，一个车间的工作过程是一个进程，车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一条流水线。

所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

多线程（即多个控制线程）的概念是，在一个进程中存在多个线程，多个线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。

开启线程的两种方式

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

#方法一:
# from threading import Thread
# import time

# def task(name):
#     print('%s is runing'%name)
#     time.sleep(3)
#     print('%s is done'%name)
#
# if __name__ == '__main__':
#     t = Thread(target=task,kwargs={'name':'线程'})  # 方法调用2
#     t1 = Thread(target=task,kwargs={'name':'线程1'})  # 方法调用2
#     t.start()
#     t1.start()
#     print('A')

# 方法二：
from threading import Thread
import time
class My_process(Thread): # 继承Process类
    def __init__(self,name):
        super().__init__() # 继承init方法
        self.name = name

    def run(self):  # 固定写法
        print('%s is runing'%self.name)
        time.sleep(3)
        print('%s id done'%self.name)

if __name__ == '__main__':
    t = My_process('线程')
    t.start()
    print('b')

线程与进程的区别

同一个进程内的多个线程共享该进程内的地址资源
创建线程的开销要远小于创建进程的开销（创建一个进程，就是创建一个车间，涉及到申请空间，而且在该空间内建至少一条流水线，但创建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小）

开进程的开销远大于开线程

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# 线程的开启速度比进程要快
from threading import Thread
from  multiprocessing import Process
import time
def work(name):
    print('%s is running'%name)
    time.sleep(2)
    print('%s is done'%name)

if __name__ == '__main__':
    t = Thread(target=work,args=('ab',))
    t.start()
    print('线程')
    p = Process(target=work,args=('abc',))
    p.start()
    print('主进程')
'''
ab is running
线程
主进程
abc is running
ab is done
abc is done
'''

同一进程内的多个线程共享该进程的地址空间

from threading import Thread
from  multiprocessing import Process
import time
n = 100
def num():
    global n
    n = 0
if __name__ == '__main__':
    t = Thread(target=num)
    t.start()
    t.join()
    print('线程',n) # 同一进程内开启的多个线程是共享该进程地址空间的
    # p = Process(target=num)
    # p.start()
    # p.join()
    # print('进程',n)  # 进程之间，地址空间是隔离的
'''
线程 0
进程 100
'''

瞅一眼PID

from threading import Thread
from multiprocessing import Process
from multiprocessing import current_process
import os
#开多个进程,每个进程都有不同的pid
# def task():
#     print('子进程的PID:%s,主进程PID:%s'%(os.getpid(),os.getppid()))
#
# if __name__ == '__main__':
#     p = Process(target=task)
#     p.start()
#     print('主进程的PID:%s'%os.getpid())
'''
主进程的PID:32228
子进程的PID:18680,主进程PID:32228
'''
#在主进程下开启多个线程,每个线程都跟主进程的pid一样
def task1():
    print('主线程的PID:%s'%os.getpid())

if __name__ == '__main__':
    t = Thread(target=task1,)
    t.start()
    print('主线程的pid:%s'%os.getpid())
'''
主线程的PID:24260
主线程的pid:24260
'''

Thread对象的其它属性方法

介绍

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

例子：

from threading import Thread
import threading
import  time

def work():
    time.sleep(3)    print(threading.current_thread().name)

if __name__ == '__main__':
    t = Thread(target=work)
    t.start()
  print(threading.current_thread().getName())
    print(threading.current_thread())#　主线程
    print(threading.enumerate()) # 连同主线程有两个正
    print(threading.active_count()) # 返回线程的数量
    print('主线程')
'''
MainThread
<_MainThread(MainThread, started 29804)>
[<_MainThread(MainThread, started 29804)>, <Thread(Thread-1, started 23704)>]
2
主线程
Thread-1
'''

主线程等待子线程结束

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

from threading import Thread
import threading
import  time

def work():
    time.sleep(3)
    print(threading.current_thread().name)

if __name__ == '__main__':
    t = Thread(target=work,name='test')
    t.start()
    t.join()
    print(t.is_alive())
    print('主线程')
'''
test
False
主线程
'''