本文内容皆为作者原创，如需转载，请注明出处：https://www.cnblogs.com/xuexianqi/p/12781703.html

一：致命3连

1.什么是线程

进程:资源单位
线程:执行单位

将操作系统比喻成一个大的工厂
那么进程就相当于工厂里面的车间
而线程就是车间里面的流水线

每一个进程肯定自带一个线程

再次总结:
   进程:资源单位(起一个进程仅仅只是在内存空间中开辟一块独立的空间)
   线程:执行单位(真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程索要)
   
进程和线程都是虚拟单位，只是为了我们更加方便的描述问题

2.为什么要有线程

开设进程
   1.申请内存空间   耗资源
   2.“拷贝代码”   耗资源
开线程
   一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间操作

总结:
   开设线程的开销要远远的小于进程的开销
   同一个进程下的多个线程数据是共享的!!!

3.怎么用线程

看下面！！！

二：创建线程的2种方式

from threading import Thread
import time


def task(name):
    print(f'{name} is running', end='')
    time.sleep(1)
    print(f'{name} is over')
    # print('%s is running' %name)
    # time.sleep(1)
    # print('%s is over' % name)


# 开启线程 不需要再main下面执行代码 直接书写就可以
# 但是我们还是习惯性地将启动命令写在main下面


if __name__ == '__main__':  # 开启线程不需要一定在main下执行，此处只是书写习惯
    t = Thread(target=task, args=('xxq',))
    t.start()
    # t.join()
    print('主')


# 输出
# xxq is running主
# xxq is over

# 类的继承创建线程
from threading import Thread
import time


class MyThread(Thread):
    # 以__开头__结尾的方法统一读成双下XXX，此处init方法应该读成双下init，避免与以__开头的隐藏属性弄混淆
    def __init__(self, name):
        # 重写了别人的方法，但是又不知道别人的方法里有啥，你就调用父类的方法
        super().__init__()
        self.name = name

    def run(self):
        print('%s running...' % self.name)
        time.sleep(2)
        print('%s over...' % self.name)


if __name__ == '__main__':
    t = MyThread('xxq')
    t.start()
    print('主')


# 输出
# xxq running...主
#
# xxq over...

三：实现TCP服务端并发的效果

low版（启动服务端，只能服务一个客户端）

# 服务端

import socket
from threading import Thread
from multiprocessing import Process
'''
服务端：
    1.要有固定的IP和PORT
    2.要24小时不间断地提供服务
    3.能够支持并发
    
从现在开始要养成一个 看源码的习惯
    我们前期要立志成为拷贝忍者（旗木卡卡西）不要有任何的创新
    等你拷贝到一定的程度了 就可以开发自己的思想了

'''
server = socket.socket()    # 括号内不可加参数，默认就是TCP协议
server.bind(('127.0.0.1', 8080))
server.listen(5)


# 链接循环
while True:
    conn, addr = server.accept()    # 解压赋值
    # 通信循环（low版）
    while True:
        try:
            data = conn.recv(1024)
            # 针对mac Linux：客户端 断开链接后，频繁收到 空
            if len(data) == 0:
                break
            print(data.decode('UTF-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

# 客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'Hello World')  # b的方式转换，要确保内容里没有中文
    data = client.recv(1024)
    print(data.decode('UTF-8'))

high版（启动服务端，只能服务一个客户端）

# 服务端

server = socket.socket()    # 括号内不可加参数，默认就是TCP协议
server.bind(('127.0.0.1', 8080))
server.listen(5)


# 将 服务的代码 单独封装成 一个函数
def talk(conn):
    # 通信循环（high版）
    while True:
        try:
            data = conn.recv(1024)
            # 针对mac Linux：客户端 断开链接后，频繁收到 空
            if len(data) == 0:
                break
            print(data.decode('UTF-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()


# 链接循环
while True:
    conn, addr = server.accept()    # 接客 只需要1个人
    # 叫其他人来服务客户
    t = Thread(target=talk, args=(conn,))
    t.start()

客户端可以设置同时运行多个（并行）

# 客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'Hello World')  # b的方式转换，要确保内容里没有中文
    data = client.recv(1024)
    print(data.decode('UTF-8'))

知识拓展：

data = 'Hello World'


# 字符串 转 二进制
data = bytes(data, encoding='UTF-8')
print(data, type(data))     # b'Hello World' <class 'bytes'>    # 二进制类型

# 二进制 转 字符串
data = str(data, encoding='UTF-8')
print(data, type(data))     # Hello World <class 'str'>     # 字符串类型

四：线程对象的join方法

未加join

from threading import Thread
import time

def task(name):
    print(f'{name} is running')
    time.sleep(3)
    print(f'{name} is running')


if __name__ == '__main__':
    t = Thread(target=task, args=('xxq',))
    t.start()
    print('主')

# 输出：
# xxq is running
# 主
# xxq is running

加join

from threading import Thread
import time

def task(name):
    print(f'{name} is running')
    time.sleep(3)
    print(f'{name} is running')


if __name__ == '__main__':
    t = Thread(target=task, args=('xxq',))
    t.start()
    t.join()    # 主线程 等待子线程运行结束 再执行
    print('主')

# 输出：
# xxq is running
# xxq is running
# 主

五：同一个进程下多个线程数据共享

from threading import Thread
import time

money = 100


def task():
    global money
    money = 666
    print('子线程', money)


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    t.join()
    print('主线程', money)


# 输出：
# 子线程 666
# 主线程 666

六：线程对象属性及其方法

os.getpid()查看当前进程的ID

from threading import Thread, active_count, current_thread
import os
import time


def task():
    print('hello world', os.getpid())


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主', os.getpid())     # 查看当前进程的ID，如果一样，就说明在同一个进程下

# hello world 3604
# 主 3604

current_thread().name查看当前线程名称

from threading import Thread, active_count, current_thread
import os
import time


def task():
    print('hello world', current_thread().name)


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主', current_thread().name)     # 查看当前线程名称


# hello world主 MainThread
#  Thread-1

查看当前线程名称 - 多个线程

from threading import Thread, active_count, current_thread
import os
import time


def task():
    print('hello world', current_thread().name)


if __name__ == '__main__':
    t = Thread(target=task)
    t1 = Thread(target=task)
    t2 = Thread(target=task)
    t.start()
    t1.start()
    t2.start()
    print('主', current_thread().name)     # 查看当前线程名称


# hello world Thread-1
# hello world Thread-2
# hello world Thread-3
# 主 MainThread

active_count() 统计当前正在活跃的线程数

from threading import Thread, active_count, current_thread
import os
import time


def task(n):
    print('hello world', current_thread().name)
    time.sleep(n)


if __name__ == '__main__':
    t = Thread(target=task, args=(1,))
    t1 = Thread(target=task, args=(2,))
    t.start()
    t1.start()
    t1.join()
    print('主', active_count())     # 统计当前正在活跃的线程数


# hello world Thread-1
# hello world Thread-2
# 主 1

# 说明：t1睡2S，但是t睡了1S后，运行结束，此时只剩下了t1，所以此时活跃的线程只有1个

七：守护线程

未加守护

from threading import Thread
import time

def task(name):
    print(f'{name} is running')
    time.sleep(1)
    print(f'{name} is over')


if __name__ == '__main__':
    t = Thread(target=task, args=('egon',))
    t.start()
    print('主')

# egon is running主
#
# egon is over

# 主线程运行结束之后不会立刻结束 会等待所有其他非守护线程结束才会结束
#     因为主线程的结束意味着所在的进程的结束

加守护

from threading import Thread
import time

def task(name):
    print(f'{name} is running')
    time.sleep(1)
    print(f'{name} is over')


if __name__ == '__main__':
    t = Thread(target=task, args=('egon',))
    t.daemon = True
    t.start()
    print('主')

# egon is running主

稍微有一点迷惑性的例子

from threading import Thread
import time

def foo():
    print(123)
    time.sleep(3)
    print('end 123')


def func():
    print(456)
    time.sleep(3)
    print('end 456')


if __name__ == '__main__':
    t1 = Thread(target=foo)
    t2 = Thread(target=func)
    t1.daemon = True
    t1.start()
    t2.start()
    print('主...')

# 123
# 456
# 主...
# end 123
# end 456

八：线程互斥锁

加锁之前

from threading import Thread
import time

money = 100


def task():
    global money
    tmp = money
    time.sleep(1)   # 模拟网络延迟
    money = tmp - 1


if __name__ == '__main__':
    t_list = []
    for i in range(100):
        t = Thread(target=task)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)

# 输出：99  因为所有的线程拿到的都是1，都执行了一次，进行了同一步操作：100-1

加锁之后

from threading import Thread
from multiprocessing import Lock
import time

money = 100
mutex = Lock()

def task():
    global money
    mutex.acquire()     # 先抢锁
    tmp = money
    time.sleep(0.1)   # 模拟网络延迟0.1
    money = tmp - 1
    mutex.release()     # 然后释放锁


if __name__ == '__main__':

    t_list = []
    for i in range(100):
        t = Thread(target=task)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)

# 输出：0

九：GIL全局解释器锁

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple 
native threads from executing Python bytecodes at once. This lock is necessary mainly 
because CPython’s memory management is not thread-safe. (However, since the GIL 
exists, other features have grown to depend on the guarantees that it enforces.)

在CPython中，全局解释器锁（GIL）是一个互斥锁，它可以防止同时执行Python字节码的本机线程。这个锁主要是必要的
因为CPython的内存管理不是线程安全的。（然而，自从GIL存在，其他功能已经增长到依赖于它所执行的保证。）

python解释器其实有多个版本
   Cpython
   Jpython
   Pypypython
但是普遍使用的都是CPython解释器

在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行
   同一个进程下的多个线程无法利用多核优势！！！
   疑问:python的多线程是不是一点用都没有？？？无法利用多核优势
   
因为cpython中的内存管理不是线程安全的
内存管理(垃圾回收机制)
   1.应用计数
   2.标记清楚
   3.分代回收

重点！

   1.GIL不是python的特点而是CPython解释器的特点
   2.GIL是保证解释器级别的数据的安全
   3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)
   4.针对不同的数据还是需要加不同的锁处理 
   5.解释型语言的通病:同一个进程下多个线程无法利用多核优势

GIL与普通互斥锁的区别

from threading import Thread,Lock
import time


mutex = Lock()
money = 100


def task():
    global money
    # with mutex:
    #     tmp = money
    #     time.sleep(0.1)
    #     money = tmp -1
    mutex.acquire()
    tmp = money
    time.sleep(0.1)  # 只要你进入IO了 GIL会自动释放
    money = tmp - 1
    mutex.release()


if __name__ == '__main__':
    t_list = []
    for i in range(100):
        t = Thread(target=task)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(money)
    
    
# 0

100个线程起起来之后  要先去抢GIL
我进入io GIL自动释放 但是我手上还有一个自己的互斥锁
其他线程虽然抢到了GIL但是抢不到互斥锁 
最终GIL还是回到你的手上 你去操作数据

十：同一个进程下的多线程无法利用多核优势,是不是就没有用了

多线程是否有用要看具体情况
单核:四个任务(IO密集型\计算密集型)
多核:四个任务(IO密集型\计算密集型)

# 计算密集型   每个任务都需要10s
    单核(不用考虑了)
       多进程:额外的消耗资源
      多线程:介绍开销
    多核
       多进程:总耗时 10+
      多线程:总耗时 40+
  
  
# IO密集型  
    多核
       多进程:相对浪费资源
      多线程:更加节省资源

计算密集型：

from multiprocessing import Process
from threading import Thread
import os, time


def work():
    res = 0
    for i in range(1000000):
        res *= i


if __name__ == '__main__':
    l = []
    print(os.cpu_count())  # 获取当前计算机CPU个数
    start_time = time.time()
    for i in range(12):
        p = Process(target=work)  # 1.4679949283599854
        t = Thread(target=work)  # 5.698534250259399
        t.start()
        # p.start()
        # l.append(p)
        l.append(t)
    for p in l:
        p.join()
    print(time.time() - start_time)

# 4
# 0.8073785305023193

IO密集型：

from multiprocessing import Process
from threading import Thread
import os,time


def work():
    time.sleep(2)

if __name__ == '__main__':
    l = []
    print(os.cpu_count())  # 获取当前计算机CPU个数
    start_time = time.time()
    for i in range(40):
        # p = Process(target=work)  # 21.149890184402466
        t = Thread(target=work)  # 3.007986068725586
        t.start()
        # p.start()
        # l.append(p)
        l.append(t)
    for p in l:
        p.join()
    print(time.time()-start_time)

总结：

多进程和多线程都有各自的优势
并且我们后面在写项目的时候通常可以
   多进程下面再开设多线程
这样的话既可以利用多核也可以介绍资源消耗

原文地址：https://www.cnblogs.com/xuexianqi/p/12781703.html