编程语言
首页 > 编程语言> > python入门学习篇二十八

python入门学习篇二十八

作者:互联网

线程

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

进程是资源分配的最小单位,线程是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)

 

搜索

复制

标签:__,入门,Thread,二十八,python,进程,线程,print,import
来源: https://www.cnblogs.com/zhangrukai/p/15942975.html