Python 多线程

# 线程
# 1.Thread
import threading
def func(a,b):
    pass
t1 = threading.Thread(target=func, args=(1,2,))
t1.start()
# 2.继承
class MyThread(threading.Thread):
    def run(self, a,b):
        pass
t1 = MyThread(args=(1,2,))
t1.start()
# 进程
import multiprocess
def func(a,b):
    pass
t1 = multiprocess.Process(target=func, args=(1,2,))
t1.start()

# 进程和线程区别：
# 1.进程是包含线程，也就是线程是在进程中创建了，一个进程可以创建多个线程。进程在创建的时候会默认创建一个进程，该进程称之为主线程，我们的代码都是由主线程开始的，所以我们在主线程中创建的线程都称之为子线程。
# 2.CPU调度是以进程为单位的，每个进程都是有GIL锁存在的。GIL锁的功能是保证CPU调度同一时刻只有一个现在被CPU调用。
# 3.因为GIL的存在掉，所以并行处理我们到底应该采用多线程还是多进程，它的标准就是你的程序需要CPU计算的强度来决定。如果你的程序是用来公式计算、数据分析就选多进程，如果你的程序偏I/O或者网络传输你就选线程，或者多进程和多线程配合使用。

# 线程方法
t1.join() # 主线程创建并t1.start()后，主线程调用t1.join()后就会阻塞等待t1线程执行完
t1.setDeamon(False) # 主线程中调用，是否等待子线程执行完。和t1.join()一个意思，区别是：setDeamon必须在start之前执行，并且是在主线程结束的时候去检查子线程是否结束
t1.setName(str)  # 设置线程的名字，也是在start前设置
threading.current_thread().getName() # 获取当前线程的名字

# 线程锁
import threading
lock_obj = threading.RLock()  # threading.Lock()  他们的区别是RLock嵌套锁
data = [1,2,3,4]
def func(a,b):
    lock_obj.acquire()  # 申请锁，没申请到就等待
    lock_obj.acquire()  # RLock嵌套锁才可以重复申请锁
    data  # 中间访问的数据就是被锁住的数据
    lock_obj.release() 
    lock_obj.release()  # 释放锁，别的线程才可以使用
t1 = threading.Thread(target=func, args=(1,2,))
t1.start()
# 线程安全：在python中一些数据类型里有些函数是自动带有线程锁的，比如：
list.append(x)
list.extend(1,2)
x = list[i]
list.sort()
x = y
x.field = y
dict[key] = xx
dict.update(d1)
dict.keys()

# 线程池:
# 线程多到一定程度并不会提高工作效率，反而会有影响
# 线程池就是用来限制同一时间最多有多少个线程在运行
# 如果你的线程池子设置最多同时执行10个线程，而往线程池中推送一百个任务的话，那么线程池子就会排队去执行它，保证同一时间最多只有10个线程运行
import time
import random
from concurrent.futures import ThreadPoolExecutor, Future

def task(video_url, t):
    print('线程开始：', video_url)
    time.sleep(2)
    return random.randint(1, 10)
def done(response):
    print('任务执行结果', response.result())
def save(filename):
    def savefile(response):
        print('闭包的方式将函数名传过来了', filename)
    return savefile
pool = ThreadPoolExecutor(10) # 创建线程池，最多同时开启10个线程
url_list = ['www.xxxx-().com'.format(i) for i in range(15)]
for url in url_list:
    future = pool.submit(task, url, 'filename')  # 提交一个任务，第一个参数就是任务的函数名，后面跟的是函数的参数
    future.add_done_callback(done)   # 当任务执行完了之后，会将执行结果当做参数船给done函数执行
    # future.add_done_callback(save('filename')) 也可以利用闭包的方式将文件名参数提前传到函数中去
pool.shutdown(True)  # 相当于线程中的join

# 多线程单例模式
import threading
import time

class Singleton(threading.Thread):
    instance = None
    lock = threading.RLock()
    
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name
    def __new__(cls, *args, **kwargs):
        if cls.instance:
            return cls.instance
        with cls.lock:  # 自动枷锁解锁。如果不枷锁的话，当多个线程同时创建单例的时候很有可能会创建多个
            if cls.instance:
                return cls.instance
            cls.instance = object.__new__(cls)
            time.sleep(0.1)
            return cls.instance