import os
import time
import threading
from concurrent.futures import ThreadPoolExecutor
lock = threading.RLock()
lock.acquire()
lock.release()
def task(num):
    with lock:
        print(os.getpid(), os.getppid(), threading.current_thread().getName())  # 或者threading.current_thread().name
t_list = []
for i in range(5):
    t = threading.Thread(target=task, args=(1,))
    t_list.append(t)
    t.setDaemon(False)  # False默认等待
    t.setName('线程{}号'.format(i))
    t.start()
# 可以用这种方式等待多个线程结束再向下运行
for i in t_list:
    i.join()
print('下面是线程池')
time.sleep(1)
def fuc(st, num):
    global count
    num += 1
    count += 1
    print(num)  # 等于1 只执行一次 要么就global
    print(count)
    return st
def outer(st):
    def done(response):
        print(response.result() + st)
    return done
pool = ThreadPoolExecutor(4)
num = 0
count = 0
for i in range(6): #一样会有输出混乱问题
    future = pool.submit(fuc, '你好', num)
    future.add_done_callback(outer('啊'))
pool.shutdown(True)
print(num)  # 还等于0
print(count)# 结果为6
#单例模式
print('单例模式')
time.sleep(1)
class Singleton:
    instance = None
    lock = threading.RLock()
    def __init__(self, name):
        self.name = name
    def __new__(cls, *args, **kwargs):
        if cls.instance:
            return cls.instance
        with cls.lock:
            if cls.instance:
                return cls.instance
            time.sleep(0.1)
            cls.instance = object.__new__(cls)
        return cls.instance
def task():
    obj = Singleton('x')
    print(obj)
for i in range(10):
    t = threading.Thread(target=task)
    t.start()
# 执行1000行代码
data = Singleton('asdfasdf')
print(data)

import os
import time
import threading
import multiprocessing  # 或者用from multiprocessing import Process 都一样
from concurrent.futures import ProcessPoolExecutor
#print('以下是进程代码') 这行代码如果不注释的话会执行很多遍 此为多进程，每个进程相当于有这个一个python文件
def task(xx):
    time.sleep(1) #为了让后面输出正确的线程个数，正常为4  如果太快，会显示只有该进程一个主线程
def fuc1(lock):
    lock.acquire()
    for i in range(3):
        t = threading.Thread(target=task, args=(1,))
        t.start()
    print(os.getpid(), os.getppid(), multiprocessing.current_process().name)
    print('该进程有{}个线程\n'.format(len(threading.enumerate())))#主线程加后加的线程
    lock.release()
def fuc2(num,url):
    return '你好'
def outer(xx):
    def done(response):
        print(response.result())
    return done
if __name__ == '__main__':
    multiprocessing.set_start_method('spawn')
    lock = multiprocessing.RLock()
    cpu_num = multiprocessing.cpu_count()  # 系统cpu个数 后面应该减去一个主进程
    p_list = []
    for i in range(cpu_num - 1):
        p = multiprocessing.Process(target=fuc1, args=(lock,)) #进程不一样了 数据不共享 故args传递的地址肯定不一样
        p_list.append(p)
        p.name = '进程{}'.format(i)
        p.daemon = False  # 默认等待
        p.start()
    for i in p_list:
        i.join()
    print('\n以下是进程池代码')
    pool = ProcessPoolExecutor(4)
    for i in range(5):
        future = pool.submit(fuc2, 2, 'xxx/xxx')
        future.add_done_callback(outer('e'))
    pool.shutdown(True)

from multiprocessing import Process, Manager
def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(666)
if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list()
        p = Process(target=f, args=(d, l))
        p.start()
        p.join()

import time
​
start = time.time()
​
result = 0
for i in range(100000000):
    result += i
print(result)
​
end = time.time()
​
print("耗时：", end - start) # 耗时： 9.522780179977417

import time
import multiprocessing
​
​
def task(start, end, queue):
    result = 0
    for i in range(start, end):
        result += i
    queue.put(result)
​
​
if __name__ == '__main__':
    queue = multiprocessing.Queue()
​
    start_time = time.time()
​
    p1 = multiprocessing.Process(target=task, args=(0, 50000000, queue))
    p1.start()
​
    p2 = multiprocessing.Process(target=task, args=(50000000, 100000000, queue))
    p2.start()
​
    v1 = queue.get(block=True) #阻塞
    v2 = queue.get(block=True) #阻塞
    print(v1 + v2)
​
    end_time = time.time()
​
    print("耗时:", end_time - start_time) # 耗时: 2.6232550144195557

import multiprocessing
import threading
​
​
def thread_task():
    pass
​
​
def task(start, end):
    t1 = threading.Thread(target=thread_task)
    t1.start()
​
    t2 = threading.Thread(target=thread_task)
    t2.start()
​
    t3 = threading.Thread(target=thread_task)
    t3.start()
​
​
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=task, args=(0, 50000000))
    p1.start()
​
    p2 = multiprocessing.Process(target=task, args=(50000000, 100000000))
    p2.start()

import threading
​
number = 0
​
def _add():
    global number
    for i in range(10000000):
        number += 1
​
t = threading.Thread(target=_add)
t.start()
​
t.join() # 主线程等待中...
​
print(number)

import threading
​
​
class MyThread(threading.Thread):
    def run(self):
        print('执行此线程', self._args)
​
​
t = MyThread(args=(100,))
t.start()
import requests
import threading
​
​
class DouYinThread(threading.Thread):
    def run(self):
        file_name, video_url = self._args
        res = requests.get(video_url)
        with open(file_name, mode='wb') as f:
            f.write(res.content)
​
​
url_list = [
    ("东北F4模仿秀.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog"),
    ("卡特扣篮.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g"),
    ("罗斯mvp.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg")
]
for item in url_list:
    t = DouYinThread(args=(item[0], item[1]))
    t.start()

import threading
​
loop = 10000000
number = 0
​
​
def _add(count):
    global number
    for i in range(count):
        number += 1
​
​
def _sub(count):
    global number
    for i in range(count):
        number -= 1
​
​
t1 = threading.Thread(target=_add, args=(loop,))
t2 = threading.Thread(target=_sub, args=(loop,))
t1.start()
t2.start()
​
t1.join()  # t1线程执行完毕,才继续往后走
t2.join()  # t2线程执行完毕,才继续往后走
​
print(number)

import threading
​
num = 0
lock_object = threading.RLock()
​
​
def task():
    print("开始")
    with lock_object: # 基于上下文管理，内部自动执行 acquire 和 release
        global num
        for i in range(1000000):
            num += 1
    print(num)
​
​
for i in range(2):
    t = threading.Thread(target=task)
    t.start()

import threading
​
data_list = []
​
lock_object = threading.RLock()
​
​
def task():
    print("开始")
    for i in range(1000000):
        data_list.append(i)
    print(len(data_list))
​
​
for i in range(2):
    t = threading.Thread(target=task)
    t.start()

import threading
​
num = 0
lock_object = threading.Lock()
​
​
def task():
    print("开始")
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    global num
    for i in range(1000000):
        num += 1
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    print(num)
​
​
for i in range(2):
    t = threading.Thread(target=task)
    t.start()

import threading
​
num = 0
lock_object = threading.RLock()
​
​
def task():
    print("开始")
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    global num
    for i in range(1000000):
        num += 1
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    print(num)
​
​
for i in range(2):
    t = threading.Thread(target=task)
    t.start()

import threading
import time
​
lock_object = threading.RLock()
​
​
def task():
    print("开始")
    lock_object.acquire()
    lock_object.acquire()
    print(123)
    lock_object.release()
    lock_object.release()
​
​
for i in range(3):
    t = threading.Thread(target=task)
    t.start()

import threading
​
num = 0
lock_object = threading.Lock()
​
​
def task():
    print("开始")
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    global num
    for i in range(1000000):
        num += 1
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    print(num)
​
​
for i in range(2):
    t = threading.Thread(target=task)
    t.start()
​

import time
from concurrent.futures import ThreadPoolExecutor
def task(video_url):
    print("开始执行任务", video_url)
    time.sleep(5)
# 创建线程池，最多维护10个线程。
pool = ThreadPoolExecutor(10)
url_list = ["www.xxxx-{}.com".format(i) for i in range(300)]
for url in url_list:
    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。
    pool.submit(task, url)
print("执行中...")
pool.shutdown(True)  # 等待线程池中的任务执行完毕后，在继续执行
print('继续往下走')

import time
import random
from concurrent.futures import ThreadPoolExecutor, Future
def task(video_url):
    print("开始执行任务", video_url)
    time.sleep(2)
    return random.randint(0, 10)
def done(response):
    print("任务执行后的返回值", response.result())
# 创建线程池，最多维护10个线程。
pool = ThreadPoolExecutor(10)
url_list = ["www.xxxx-{}.com".format(i) for i in range(15)]
for url in url_list:
    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。
    future = pool.submit(task, url)
    future.add_done_callback(done) # 是子主线程执行
# 可以做分工，例如：task专门下载，done专门将下载的数据写入本地文件。

import time
import random
from concurrent.futures import ThreadPoolExecutor,Future
def task(video_url):
    print("开始执行任务", video_url)
    time.sleep(2)
    return random.randint(0, 10)
# 创建线程池，最多维护10个线程。
pool = ThreadPoolExecutor(10)
future_list = []
url_list = ["www.xxxx-{}.com".format(i) for i in range(15)]
for url in url_list:
    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。
    future = pool.submit(task, url)
    future_list.append(future)
pool.shutdown(True)
for fu in future_list:
    print(fu.result())

import os
import requests
from concurrent.futures import ThreadPoolExecutor
def download(image_url):
    res = requests.get(
        url=image_url,
        headers={
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
        }
    )
    return res
def outer(file_name):
    def save(response):
        res = response.result()
        # 写入本地
        # # 检查images目录是否存在？不存在，则创建images目录
        if not os.path.exists("images"):
            # 创建images目录
            os.makedirs("images")
        file_path = os.path.join("images", file_name)
        # # 2.将图片的内容写入到文件
        with open(file_path, mode='wb') as img_object:
            img_object.write(res.content)
    return save
# 创建线程池，最多维护10个线程。
pool = ThreadPoolExecutor(10)
with open("mv.csv", mode='r', encoding='utf-8') as file_object:
    for line in file_object:
        nid, name, url = line.split(",")
        file_name = "{}.png".format(name)
        fur = pool.submit(download, url)
        fur.add_done_callback(outer(file_name))