Python第九课json文件操作及多线程

一、json是各种语言的媒介

import json
d=json.load(s)    把json串转为字典
s=json.dump(d)    把字典转为字符串

二、多线程
什么是线程
线程 >>>轻量级进程 >>>操作系统能够进行运算调度的最小单位，被包含在进程中，是进程中的实际运作单位。>>>线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源，一个线程可以创建和撤销另一个线程，同一个进程中的多个线程可以并发执行。
多线程的优点

1. 进程间不能共享内存，但线程之间共享内存很容易
2. 操作系统在创建进程时需要为该进程重新分配系统资源 ，但创建线程的代价则小得多，因此使用多线程并发执行比使用多进程的效率高
3. python语言内置了多线程功能的支持
   但python的多线程是伪多线程，实际上是一个cpu来回切换执行线程，造成一种多线程的假象，在一时刻只有一个线程进行
   普通创建多线程

import threading
import time
def run(n):
    print("task",n)
    time.sleep(1)
    print("3s")
    time.sleep(1)
    print("2s")
    time.sleep(1)
    print("1s")
    time.sleep(1)
    print("0s")
    time.sleep(1)
def run(n):
    for i in range(1,101):
        print(n,"跑了",i,"米")
if __name__ == '__main__':
    t1 = threading.Thread(target=run,args=("刘",))   target指向方法 args指向传入的参数（元组，）原方法需要传入两个参数
    t2 = threading.Thread(target=run, args=("付",))
    t3 = threading.Thread(target=run, args=("孙",))
    
    t1.start()     开始运行线程
    t2.start()
    t3.start()

自定义线程
继承threading.Thread来自定义线程类，其本质是重构Thread类中的run方法

class MyThread(threading.Thread):    继承父类
    def __init__(self,n):
        super().__init__()           调用父类方法
        self.n = n
    def run(self):
        for i in range(1,101):
            print(self.n,"跑了",i,"米")

if __name__ == "__main__":
    t1 = MyThread("付")             只需传入一个参数，默认调用run方法
    t2 = MyThread("孙")  
    t3 = MyThread("刘")
    t1.start()
    t2.start()
    t3.start()

守护线程setDaemon
主线程技术子线程随主线程结束而结束

t1.setDaemon(True)    把t1设置为守护线程
t2.setDaemon(True)
t3.setDaemon(True)

主线程等待兹县茨城JOIN

t1.setDaemon(True)    设置守护
t1.start()            开始运行
t1.join()             主线程等待t1线程结束在结束

互斥锁Lock
一次只允许一个线程进入

from threading import Thread,Lock
import os,time
def work():
    global n
    lock.acquire()     加锁，此时只有一个进程进入
    temp=n
    time.sleep(0.1)          在修改的地方上锁
    n=temp-1
    lock.release()     释放，
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()
#lock=threading.lock（）  

递归锁Rlock
rlock锁的用法和lock锁一样，但rlock锁支持嵌套，在多个锁没有被释放时一般使用rlock锁

lock=threakding.RLock()

信号量BoundedSemaphore
一次性允许多个线程运行，可以限制锁内线程的个数

semaphore=threading.BoundedSemaphore(5)
最多允许5个线程同时进行

事件Event
用于控制其他线程的执行，事件是一个简单的线程同步对象

• clear将flag视之为Flase
• set将flag设置为True
• is_set判断是否设置了flag
• wait会一直监听flag，如果没有检测到flag就一直处于阻塞状态
  事件处理机制：全局定义一个"Flag"，当flag值为Flase，那么event.wait()就会阻塞，当flag值为True，那么event.wait()不再阻塞.。

# 利用Event类模拟红绿灯
import threading
import time
event = threading.Event()
def lighter():
    count = 0
    event.set()            		# 初始值为绿灯
    while True:
        if 5 < count <= 10:
            event.clear()  		# 红灯，清除标志位
            print("\33[41;1mred light is on...\033[0m")
        elif count > 10:
            event.set()  		# 绿灯，设置标志位
            count = 0
        else:
            print("\33[42;1mgreen light is on...\033[0m")
        time.sleep(1)
        count += 1
def car(name):
    while True:
        if event.is_set():  	# 判断是否设置了标志位
            print("[%s] running..." % name)
            time.sleep(1)
        else:
            print("[%s] sees red light,waiting..." % name)
            event.wait()
            print("[%s] green light is on,start going..." % name)
light = threading.Thread(target=lighter, )
light.start()
car = threading.Thread(target=car, args=("MINI",))
car.start()

GIL（global interperter lock）全局解释器锁
在非python环境中，单核情况下，同时只能有一个任务执行。多核时支持多个线程同时执行。但在python中，无论有多少个核，同时只能执行一个线程，就是gil导致的。
通俗而言就是，在执行一个进程中一个大锁把所有的线程固定在一个核上