线程、开启线程的两种方式、线程下的Join方法、守护线程、线程互斥锁、GIL锁

【线程理论】

1.什么是线程？
进程：资源单位，仅仅是在内存空间中开辟一块独立的空间
线程：程序执行单位(真正被CPU执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程索要)
（每一个进程自带一个线程）

2.为什么要有线程
开设进程：
    1.申请内存空间    耗资源
    2.“拷贝代码”        耗资源
开线程：
    一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间及靠欸代码的操作
总结：开设线程比开设进程的开销小，同一个进程下的多个线程数据是共享的
　　

3.进程之间和线程之间是合作还是竞争？

进程是开辟出的独立的内存地址 ---> 抢资源 (内存、硬盘、网络 ... ) ---> 对于进程与进程之间来说 竞争
线程是开设在进程内部 --> 共享一块资源 ----> 对于线程来说是合作

4.什么是多线程

多线程指的是
在一个进程中开启多个线程
简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。
多线程共享一个进程的地址空间
线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用
若多个线程都是cpu密集型的，那么并不能获得性能上的增强
但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。
在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于Python）

 

【创建线程的两种方式】

第一种：

def task(name):
    print('%s is running' % name)
    time.sleep(2)
    print('%s is over' % name)


# 开启线程不需要在main下面执行代码，直接书写就可以
t = Thread(target=task, args=('egon',))
t.start()  # 创建线程的开销非常小，几乎是代码一执行线程就已经创建好啦
print('主')


================================================
第二种：

from threading import Thread
import time


# （类继承）
class MyThead(Thread):
    def __init__(self, name):
        # 重写别人的方法，又不知道别人的方法里有啥，就调用父类的方法
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(1)
        print('小可爱')


if __name__ == '__main__':
    t = MyThead('egon')
    t.start()
    print('主')
这行代码可能在线程开始之前、之中或之后打印，取决于操作系统的线程调度
=================
先运行running,再运行主

。

。

【TCP服务端实现并发】

服务端

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)


# 将服务的代码单独封装成一个函数
def talk(conn):
    # 通信循环
    while True:
        try:
            data = conn.recv(1024)
            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()
    # # 叫其他人来服务客户
    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')
    data = client.recv(1024)
    print(data.decode('utf-8'))

。

。

【join 方法】

from threading import Thread
import time


def task(name):
    print('%s is running' % name)
    time.sleep(1)
    print('%s is over' % name)


if __name__ == '__main__':
    t = Thread(target=task, args=('egon',))
    t.start()
    # 想等到子线程运行完毕在运行
    t.join()
    print('主')

。

。

【线程的诸多特性】

1.线程的join方法，主线程代码等待子线程代码运行结束再往下运行！！！ （和线程的join方法特性一样）

2.同一个进程内多个线程数据共享

3.current_thread().name # 查看进程下的线程名

4.active_count() # 查看进程下的线程数

from threading import Thread
import time

# ========================验证同一个进程下的多个线程数据共享
money = 100


def task():
    global money
    money = 666


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    # t.join()
    print(money)  # 666


------------------------------------------
同一个进程内多个线程数据共享，所以子线程将主线程里面的全局变量money的值改了，
主线程与子线程都在一个进程里面，都在一个内存空间内。

。

。

【线程对象及其他方法】

# 线程对象及其他方法
import os, time
from threading import Thread, active_count, current_thread


def task():
    print('hello world', os.getpid())
    print('hello', current_thread().name)  # 获取线程名字,Thread-1


if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print('主', os.getpid())  # 两个进程号一样，证明两个线程在同一个进程下
    print('主线程名字', current_thread().name)  # MainThread
    print('主', active_count())  # 统计当前正在活跃的线程数


---------------------------------------------------------------------------------
active_count：统计当前正在活跃的线程数

 current_thread（）.name获取线程名字

 。

。

【守护线程】

 。

。

【线程互斥锁】

from threading import Thread, Lock
import time

money = 100
# 给一把锁，防止数据错乱
mutex = Lock()


def task():
    global money
    # 让大家抢锁
    mutex.acquire()
    tmp = money  # 先获取到money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()


if __name__ == '__main__':
    t_list = []  # 为了保证100个线程都能打印完
    for i in range(100):
        t = Thread(target=task)
        t.start()
        t_list.append(t)

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

# 加锁，将并发变成串行

。

。

【GIL锁】

1 GIL：Global Interpreter Lock又称全局解释器锁
2 保证了cpython进程中得每个线程必须获得这把锁才能执行，不获得不能执行
3 使得在同一进程内任何时刻仅有一个线程在执行
4 gil锁只针对于cpython解释器----》目前基本都是在用cpython解释器
5 针对不同的数据类型，需要加不同的锁处理

 --------不是一个好的东西--python多线程是伪多线程--------------
为什么要有gil锁？
    -垃圾回收是垃圾回收线程，它在执行的时候，其他线程是不能执行的，而限于当时的条件，只有单核cpu，
    所以作者直接做了个GIL锁，保证一个进程内同一时刻只有一个线程在执行，但是后来随着多核机器的出现，就导致cpython解释器开启了多线程不能利用多核优势


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

 

 

【GIL锁与普通互斥锁的区别】

# =======================验证GIL会导致同一个进程下的多个线程的无法同时执行，即无法利用多核优势
from threading import Thread, Lock
import time

money = 100
mutex = Lock()


def task():
    global money
    mutex.acquire()
    # 方式一：
    # with mutex:
    #     tmp = money  # 先获取到money
    #     time.sleep(0.1)   # 没有这一步，结果是0
    #     money = tmp - 1
    # 方式二：
    tmp = money  # 先获取到money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()


if __name__ == '__main__':
    t_list = []  # 为了保证100个线程都能打印完
    for i in range(100):
        t = Thread(target=task)
        t.start()
        t_list.append(t)

    for t in t_list:
        t.join()
    print(money)
'''
    100个线程起起来之后，要先去抢GIL
    我进入IO GIL自动释放，但是我手上还有一个自己的互斥锁
    其他线程虽然抢到了GIL,但是没抢到互斥锁
    最终GIL还是回到了你的手上，你去操作数据 
'''


==============================================

# ================验证同一个进程下的多线程无法利用多核优势，是不是就没有用了？==============
'''
要看具体情况：
    单核：四个任务（IO密集型\计算密集型）
    多核：四个任务（IO密集型\计算密集型）

# 计算密集型  每个任务都需要10s
    单核：
        多进程：额外的消耗资源
        多线程：减少开销
    多核：
        多进程：额外的消耗资源  10+(总耗时)
        多线程：减少开销       40+

# IO密集型  每个任务都需要10s
    多核：
        多进程：相对浪费资源
        多线程：更加节省资源
'''

# 代码验证上述问题
# 计算密集型(进程胜出)
from threading import Thread
import time, os
from multiprocessing import Process


def work():
    res = 1
    for i in range(1000000):
        res += i + 1


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

================================================
# ====================IO密集型(多线程胜出)
def work():
    time.sleep(1)


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




# 总结：多线程和多进程都有各自的优势，以后我们可以在多进程下面再开设多线程，这样的话可以利用多核也可以节省资源消耗