互斥锁、线程理论、创建线程的多种方式、线程的相关方法、GIL全局解释器锁

2022-08-10 22:32:40 阅读：130 来源： 互联网

标签：__ name Thread 互斥线程 print import GIL

练习

尝试将TCP服务端制作成并发效果：客户端服务端全部设置成自动发消息自动回消息
eg: 客户端发hello 服务端直接转大写回HELLO

服务端:
import socket
from multiprocessing import Process
def server_get():
    server = socket.socket()
    server.bind(('127.0.0.1',8080))
    server.listen(5)
    return server
def run(sock):
    while  True:
        try:
            data = sock.recv(1024)
            print(data.decode('utf8'))
            sock.send(data.upper())
        except ConnectionRefusedError as e:
            sock.close()
            break

if __name__ == '__main__':
    # 方式一
    # server = socket.socket()
    # server.bind(('127.0.0.1', 8080))
    # server.listen(5)
    server = server_get()
    while  True:
        sock,addr = server.accept()
        p = Process(target=run,args=(sock,))
        p.start()
        
客服端：
import socket

client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
    client.send('hello'.encode('utf8'))
    data = client.recv(1024)
    print(data.decode('utf8'))

互斥锁

多程序同时操作一份数据的时候，很容易产生数据的错乱，为了避免数据错乱，我们需要使用互斥锁;互斥锁是将并发变成串行，虽然牺牲了程序的执行效率但是保证了数据的安全

使用

互斥锁只应该在出现多个程序操作数据的地方，其他位置尽量不要加。ps:以后我们自己处理的情况很少，只需要知道锁的功能即可

from multiprocessing import Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 释放锁

抢票系统

from multiprocessing import Process,Lock
import json
import time
import random


def select_ticket(name):
    with open(r'ticket.json','r',encoding='utf8')as f :
        data = json.load(f)
    print(name,f"余票:{data.get('ticket')}")


def buy_ticket(name):
    with open(r'ticket.json', 'r', encoding='utf8')as f:
        data = json.load(f)
    time.sleep(random.randint(1,3))

    if data.get('ticket') > 0:
        data['ticket'] -= 1
        print(name,"购买成功")
    else:
        print("没票了")
    with open(r'ticket.json', 'w', encoding='utf8')as f:
        json.dump(data,f)

def run(name,mutex):
    select_ticket(name)
    mutex.acquire()
    buy_ticket(name)
    mutex.release()

if __name__ == '__main__':
    mutex = Lock()
    for i in range(10):
        p = Process(target=run,args=(i,mutex))
        p.start()

补充知识

1.行锁：访问数据库的时候，锁定整个行数据，他人不能在哪一行操作数据。
2.表锁：访问数据库的时候，锁定整个表数据，他人不能在哪一个表格操作数据。
3.乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁
4.悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁

线程理论

1.怎样理解线程和进程
	1.1 进程：进程是资源单位，进程相当于是车间，负责给内部的线程提供相应的资源
	1.2 线程： 线程是执行单位，线程相当于是车间里面的流水线，负责执行真正的功能
2.一个进程至少含有一个线程
3.多进程与多线程的区别
	3.1 多进程：需要申请内存空间，并且需要拷贝全部代码，资源消耗大
	3.2 多线程：不需要申请内存空间，也不需要拷贝全部代码，并且资源消耗小
4.同一个进程下多个线程之间资源共享

创建线程的两种方式

开设线程不需要完整拷贝代码，所以无论什么系统都不会出现反复操作的情况，也不需要在启动脚本中执行，但是为了兼容性和统一性，习惯在启动脚本中编写

方式一

from threading import Thread
import time

def task(name):
    print(f'{name} 程序开始执行')
    time.sleep(3)
    print(f"{name} 程序执行结束")

if __name__ == '__main__':
    p = Thread(target=task,args=('nana',))
    p.start()
    print("主线程")
    
结果：
    nana 程序开始执行
    主线程
    nana 程序执行结束

方式二

from threading import Thread
import time

class My_Thread(Thread):

    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print(f'{self.name} 程序开始执行')
        time.sleep(3)
        print(f"{self.name} 程序执行结束")

if __name__ == '__main__':
    p = My_Thread('nana')
    p.start()
    print("主线程")

结果：
    nana 程序开始执行
    主线程
    nana 程序执行结束

多线程实现TCP服务端开发

服务端：
import socket
from threading import Thread
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)

def run(sock):
    while  True:
        try:
            data = sock.recv(1024)
            print(data.decode('utf8'))
            sock.send(data.upper())
        except ConnectionRefusedError as e:
            sock.close()
            break
            
while  True:
    sock,addr = server.accept()
    p =  Thread(target=run,args=(sock,))
    p.start()
    
客服端：
import socket

client = socket.socket()
client.connect(('127.0.0.1',8080))
while True:
    client.send('hello'.encode('utf8'))
    data = client.recv(1024)
    print(data.decode('utf8'))

join()方法

join()方法作用：使主线程等到子线程运行结束之后再运行

from threading import Thread
import time

def task(name):
    print(f'{name} 程序开始执行')
    time.sleep(3)
    print(f"{name} 程序执行结束")

if __name__ == '__main__':
    p = Thread(target=task,args=('nana',))
    p.start()
    p.join()
    print("主线程")
    
结果：
    nana 程序开始执行
    nana 程序执行结束
    主线程

同一个进程下线程间数据共享

from threading import Thread
money = 1000
def task():
    global money
    money = 666
    print('子线程:',money)

t = Thread(target=task)
t.start()
t.join() #确保线程运行完毕再查找money,使结果更具有说服性
print('主线程：',money)

结果：
    子线程: 666
    主线程： 666

线程对象相关方法

1.进程号

同一个进程下，开设的多个线程拥有相同的进程号

from threading import Thread
import os

def task(name):
    print("子线程号：",os.getpid())

if __name__ == '__main__':
    p1 = Thread(target=task,args=('nana',))
    p2 = Thread(target=task, args=('kevin',))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    print("主线程号：",os.getpid())
    
结果：
    子线程号： 6680
    子线程号： 6680
    主线程号： 6680

2.线程名

导入from threading import current_thread，用current_thread().name查看线程名

from threading import Thread,current_thread
import time
import os

def task(name):
    print(f'{name} 程序开始执行')
    time.sleep(3)
    print(f"{name} 程序执行结束")
    print("子线程名：",current_thread().name)

if __name__ == '__main__':
    p1 = Thread(target=task,args=('nana',))
    p2 = Thread(target=task, args=('kevin',))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    print("主线程名：",current_thread().name)
结果：
    nana 程序开始执行
    nana 程序执行结束
    子线程名： Thread-1
    kevin 程序开始执行
    kevin 程序执行结束
    子线程名： Thread-2
    主线程名： MainThread

3.查看进程下的线程数

导入from threading import active_count，用active_count()查看进程下的线程数

from threading import Thread,  active_count
import time

def task():
    time.sleep(3)

if __name__ == '__main__':
    for i in range(4):
        t = Thread(target=task, )
        t.start()
    print('当前进程下存活的线程数>>>:', active_count())

守护线程

守护线程随着主线程的结束而结束(随着被守护的线程的结束而结束)

用obj.daemon = True将子线程变为守护线程，obj.daemon = True写在obj.start()前面

注意：进程下所有的非守护线程结束，主线程(主进程)才能真正的结束

from threading import Thread
import  time

def task():
    print("子线程运行task函数")
    time.sleep(3)
    print("子线程结束运行task函数")

t = Thread(target=task)
t.daemon = True
t.start()
print('主线程')
子线程运行task函数
主线程

GIL全局解释器锁

储备知识

python解释器是由编程语言写出来的，Cpython:是用C语言写出来的，

Jpthon：是用java语言写出来的，Pypython:是用python语言写出来的

官方文档对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.)
    
解读：
1.GIL的研究是Cpython解释器的特点，不是python语言的特点
2.GIL本质也是一把互斥锁
3.GIL的存在使得同一个进程下的多个线程不能同时执行(单进程下的多进程无法利用多核优势，使效率低)
4.GIL的存在主要是因为cpthon解释器中垃圾回收机制不是线程安全的

GIL的理解

1.判断：python的多线程就是垃圾，利用不到多核优势
	错误，python的多线程确实无法使用多核优势，但是在IO密集的任务下是有用的
2.判断：既然有GIL，那么以后我们写代码就不需要加互斥锁
	错误，GIL只确保解释器层面数据不会错乱(垃圾回收机制)，针对程序中自己的数据应该自己加锁处理
3.所有的解释型编程语言都没办法做到同一个进程下多个线程同时执行
ps:我们平时写代码的时候，不需要考虑GIL

标签：__,name,Thread,互斥,线程,print,import,GIL
来源： https://www.cnblogs.com/luonacx/p/16574143.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9