Python 线程 全面解析

操作系统线程理论

线程概念的引入背景

操作系统中的多线程

进程和线程的关系

线程的特点（了解）

用户级与内核级线程的对比

# 用户级线程和内核级线程的区别
'''
内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。
用户级线程的创建、撤消和调度不需要OS内核的支持，是在语言（如Java）这一级处理的；
而内核支持线程的创建、撤消和调度都需OS内核提供支持，而且与进程的创建、撤消和调度大体是相同的。
用户级线程执行系统调用指令时将导致其所属进程被中断，
	而内核支持线程执行系统调用指令时，只导致该线程被中断。
在只有用户级线程的系统内，CPU调度还是以进程为单位，处于运行状态的进程中的多个线程，
由用户程序控制线程的轮换运行；在有内核支持线程的系统内，CPU调度则以线程为单位，
由OS的线程调度程序负责线程的调度。
用户级线程的程序实体是运行在用户态下的程序，
	而内核支持线程的程序实体则是可以运行在任何状态下的程序。
'''

# 内核线程的优缺点
'''
优点：当有多个处理机时，一个进程的多个线程可以同时执行。
缺点：由内核进行调度。
'''
# 用户级线程的优缺点
'''
优点：
线程的调度不需要内核直接参与，控制简单。
可以在不支持线程的操作系统中实现。
创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。
允许每个进程定制自己的调度算法，线程管理比较灵活。
线程能够利用的表空间和堆栈空间比内核级线程多。
同一进程中只能同时有一个线程在运行，如果有一个线程使用了系统调用而阻塞，
那么整个进程都会被挂起。另外，页面失效也会产生同样的问题。

缺点：
资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用
'''

Python中的线程

理论知识

GIL全局解释器锁

'''
GIL锁，全局解释器锁。用于限制一个进程中同一时刻只有一个线程被cpu调度。

扩展：默认GIL锁在执行100个cpu指令（过期时间）。
     import sys
     v1 = sys.getcheckinterval()
     print(v1) # 100
'''

python线程模块的选择

threading模块

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性

线程的创建Threading.Thread类

线程的创建

# 创建线程的方式1

from threading import Thread
import time


def sayhi(name):
    time.sleep(2)
    print('%s say hello' % name)


if __name__ == '__main__':
    t = Thread(target=sayhi, args=('jaychou',))
    t.start()
    print('主线程') # 主线程默认等子线程执行完毕

# 创建线程的方式2--面向对象的方式

class Sayhi(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('jaychou')
    t.start()
    print('主线程') # 主线程默认等子线程执行完毕

线程的本质

import threading


# 先打印：11？123？
def func(arg):
    print(arg)


t1 = threading.Thread(target=func, args=(11,))
t1.start()
# start 是开始运行线程吗？不是
# start 告诉cpu，我已经准备就绪，你可以调度我了。
print(123)

不使用多线程和使用多线程对比

# 不使用

import requests
import uuid

url_list = [
    'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
    'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
    'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
]


def task(url):
    ret = requests.get(url)
    file_name = str(uuid.uuid4()) + '.jpg'
    with open(file_name, mode='wb') as f:
        f.write(ret.content)


for url in url_list:
    task(url)

"""
- 你写好代码
- 交给解释器运行： python s1.py
- 解释器读取代码，再交给操作系统去执行，
	根据你的代码去选择创建多少个线程/进程去执行（单进程/单线程）。
- 操作系统调用硬件：硬盘、cpu、网卡....
"""

# 使用
import threading
import requests
import uuid

url_list = [
    'https://www3.autoimg.cn/newsdfs/g28/M05/F9/98/120x90_0_autohomecar__ChsEnluQmUmARAhAAAFES6mpmTM281.jpg',
    'https://www2.autoimg.cn/newsdfs/g28/M09/FC/06/120x90_0_autohomecar__ChcCR1uQlD6AT4P3AAGRMJX7834274.jpg',
    'https://www2.autoimg.cn/newsdfs/g3/M00/C6/A9/120x90_0_autohomecar__ChsEkVuPsdqAQz3zAAEYvWuAspI061.jpg',
]


def task(url):
    ret = requests.get(url)
    file_name = str(uuid.uuid4()) + '.jpg'
    with open(file_name, mode='wb') as f:
        f.write(ret.content)


for url in url_list:
    t = threading.Thread(target=task, args=(url,))
    t.start()

多线程与多进程

# pid的比较

from threading import Thread
from multiprocessing import Process
import os


def work():
    print('hello', os.getpid())


if __name__ == '__main__':
    # part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t1 = Thread(target=work)
    t2 = Thread(target=work)
    t1.start()
    t2.start()
    print('主线程/主进程pid', os.getpid())

    # part2:开多个进程,每个进程都有不同的pid
    p1 = Process(target=work)
    p2 = Process(target=work)
    p1.start()
    p2.start()
    print('主线程/主进程pid', os.getpid())
    
'''
hello 7860
hello 7860
主线程/主进程pid 7860
主线程/主进程pid 7860
hello 10036
hello 13944
'''

# 开启效率的较量

from threading import Thread
from multiprocessing import Process
import os


def work():
    print('hello')


if __name__ == '__main__':
    # 在主进程下开启线程
    t = Thread(target=work)
    t.start()
    print('主线程/主进程')
    '''
    打印结果:
    hello
    主线程/主进程
    '''

    # 在主进程下开启子进程
    t = Process(target=work)
    t.start()
    print('主线程/主进程')
    '''
    打印结果:
    主线程/主进程
    hello
    '''

# 内存数据的共享问题

from threading import Thread
from multiprocessing import Process
import os


def work():
    global n
    n = 0


if __name__ == '__main__':
    # n=100
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print('主',n) 毫无疑问子进程p已经将自己的全局的n改成了0,
    # --但改的仅仅是它自己的,查看父进程的n仍然为100

    n = 1
    t = Thread(target=work)
    t.start()
    t.join()
    print('主', n)  # 查看结果为0,因为同一进程内的线程之间共享进程内的数据
# 同一进程内的线程共享该进程的数据？

'''
Python多线程情况下：
- 计算密集型操作：效率低。（GIL锁限制的，一个进程中只要一个线程被调用）
- IO操作： 效率高

Python多进程的情况下：
- 计算密集型操作：效率高（浪费资源）。 不得已而为之。
- IO操作： 效率高 （浪费资源）。

以后写Python时：（c python）
     IO密集型用多线程： 文件/输入输出/socket网络通信
     计算密集型用多进程。
	（pypy解决了这个问题）

扩展：
   Java多线程情况下：
	   - 计算密集型操作：效率高。
	   - IO操作： 效率高
   java多进程的情况下：（很少写）
	   - 计算密集型操作：效率高（浪费资源）。
	   - IO操作： 效率高 浪费资源）。
'''

多线程实现socket

# server端

# _*_coding:utf-8_*_
# !/usr/bin/env python
import multiprocessing
import threading

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 8080))
s.listen(5)


def action(conn):
    while True:
        data = conn.recv(1024)
        print(data)
        conn.send(data.upper())


if __name__ == '__main__':

    while True:
        conn, addr = s.accept()

        p = threading.Thread(target=action, args=(conn,))
        p.start()

# client

# _*_coding:utf-8_*_
# !/usr/bin/env python


import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', 8080))

while True:
    msg = input('>>: ').strip()
    if not msg: continue

    s.send(msg.encode('utf-8'))
    data = s.recv(1024)
    print(data)

多线程的应用场景

计算密集型多线程–多线程无用

import threading

v1 = [11, 22, 33]  # +1
v2 = [44, 55, 66]  # +100


def func(data, plus):
    for i in range(len(data)):
        data[i] = data[i] + plus


t1 = threading.Thread(target=func, args=(v1, 1))
t1.start()

t2 = threading.Thread(target=func, args=(v2, 100))
t2.start()

IO操作–多线程有用
例子：如上面的 爬虫示例

Thread类的其他方法

方法概述

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

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

# 代码示例

from threading import Thread
import threading
from multiprocessing import Process
import os


def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName()) # 获取名字


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 140735268892672)>
    [<_MainThread(MainThread, started 140735268892672)>, 
    <Thread(Thread-1, started 123145307557888)>]
    主线程/主进程
    Thread-1
    '''

threading.local()

引入前先了解一下局部变量和全局变量

# 局部变量 

import threading
import time
 
def worker():
    x = 0
    for i in range(100):
        time.sleep(0.0001)
        x += 1
    print(threading.current_thread(),x)
 
for i in range(10):
    threading.Thread(target=worker).start()
 
运行结果：
<Thread(Thread-2, started 123145372971008)> 100
<Thread(Thread-6, started 123145393991680)> 100
<Thread(Thread-1, starte