线程

# 一个进程里面至少要有一个线程，主进程里面的线程称为主线程，其他进程中的线程称为子线程

进程是资源分配的最小单位，线程是CPU调度的最小单位。每一个进程中至少有一个线程。’

# 协程：在单线程下开启协程，程序员来开的。

# 线程才是真正干活的人。

如何开启线程

from multiprocessing import Process

from threading import Thread

def write():
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('hello')


if __name__ == '__main__':
    # p = Process(target=write, )
    # p.start()
    t = Thread(target=write, )
    t.start()

进程与线程的区别

1. 进程的开销远远大于线程的开销
# 进程里面可以开很多个线程

2. 进程能利用多核优势的，线程就不能利用多核优势
但是，可以开启多个进程，在进程里面在开启线程

3. 进程之间的数据隔离的，线程之间的数据是不隔离的，前提：同一进程之间

Thread类中的几个方法

from threading import Thread

def write():
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('hello')
    print(threading.currentThread())

if __name__ == '__main__':
    # p = Process(target=write, )
    # p.start()

    t = Thread(target=write, )
    t.start()

    # print(t.is_alive())
    # print(t.getName()) # 返回线程名
    # t.setName('aaaaaaa')
    # print(t.getName())
    # print(threading.currentThread())

多线程实现socket

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()

GIL锁(全局解释器锁)

Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行

# 对Python解释器的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。

1. 我们写的代码其实是解释器在执行:
    cpython解释器，pypy解释器...
2. GIL锁只存在cpython解释器中，在其他解释器中不存在
3. 起一个垃圾回收的线程，起一个正常执行代码的线程，当垃圾回收线程还没有把垃圾回收完毕的时候，会出现抢占资源的情况。
4. 我们就需要拿到GIL锁，要想让线程能够正常执行，那么，线程就必须要拿到这把锁（GIL锁）
5. 保证了，同一时刻，只有一个线程在执行。

'''
    进程：可以利用多核，
    线程：没办法利用多核，
    
    i/o密集型：不需要计算，一般不消耗CPU，所以就选择线程比较好
    计算密集型：在消耗CPU，所以做好选择进程
'''

for i in range(1000000000000000000000000000000000000000000000):
    i+=1
    print(i)
    
import time
for i in range(1000000000000000000000000000000000000000000000):
    time.sleep(1)
    print(i)

同步锁（互斥锁）

# 开多进程或者多线程一定好吗？
不一定，虽然可以提高效率，但是，会出现安全问题
from threading import Thread, Lock
import time
n = 10


def task(lock):
    lock.acquire()  # 上锁
    global n
    # n -= 1
    temp = n
    # time.sleep(1)
    n = temp - 1  # n=n-1
    # 释放锁
    lock.release()


if __name__ == '__main__':
    lock = Lock()
    l = []
    for i in range(10):
        t = Thread(target=task, args=(lock, ))
        t.start()
        l.append(t)

    for j in l:
        j.join()
    print('n:', n)

搜索

复制