1进程

1.1什么是进程（相当于一个工厂）

进程是指在系统中正在运行的一个应用程序；
每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。

1.2什么是线程（相当于工人）

1个进程要想执行任务，必须得有线程（每个线程至少要有一条线程）
一个进程（程序）的所有任务都在线程中执行。

1.3线程的串行

1个线程中任务的执行是串行的；如果要在1个线程中执行多个任务，那么只能一个一个的按顺序执行这些任务。也就是说，在同一时间内，1个线程只能执行一个任务。

1.4什么是线程

1个进程中可以开启多条线程，每条线程可以并行（同时）执行不同的任务；多线程技术可以提高程序执行效率。

1.5多线程原理

同一时间，cpu只能处理1条线程，只有1条线程在工作（执行）；多线程并发（同时）执行，其实是cpu快速的在多条线程之间调度（切换）；如果cpu调度线程的时间足够快，就造成了多线程并发执行的假象。

2耗时操作

一个进程默认有一个线程，这个线程叫主线程。默认情况下，所有的代码都是在主线程中执行的。

time.sleep(5) # 程序执行到这个地方，线程会阻塞/停5秒，在执行后面的代码
print('%s下载结束'%file_name,datetime.datetime.now()) #打印执行这段代码的时间

3多线程一

python中提供了threading模块，来支持多线程技术；默认创建的线程叫主线程，其他的线程叫子线程。如果希望代码在子线程中执行，必须手动创建线程对象。

3.1创建线程对象

3.1.1 Thread类 - 线程类

Thread - 线程类

3.1.2 创建线程对象

Thread（target=函数名，args=参数列表） - 直接创建线程对象
函数名 = 需要在当前创建的子线程中执行的函数变量
参数列表 = 元祖，元祖的元素是需要传递给函数的实参

def download():
    pass
t1=threading.Thread(target=download,args=('地心游记',))
t2 = threading.Thread(target=download, args=('西游记',))

3.2在子线程中执行任务

在这儿就是调用t1对应的线程中调用download对应的函数，并且传递一个参数‘地心游记’

t1.start()
t2.start()

4线程类的子类

创建子线程，除了直接创建Thread的对象，还可以创建这个类的子类对象。
注意：一个进程中有多个线程，进程会在所有的线程都结束才会结束；线程中的任务执行完了，线程就结束。

from threading import Thread,current_thread
#1声明一个类继承Thread
class DownloadThread(Thread):
    #想要给run方法传递数据，通过添加对象属性来传
    def __init__(self,file_name):
        super().__init__()
        self.file_name=file_name
     # 2.重写run方法
    def run(self):
        #这个方法中的代码会在子线程中执行
        print('开始下载：%s'%self.file_name)
        print(current_thread())

# 创建线程对象
t1=DownloadThread('小黄人')
# 4.通过线程对象调用start在子线程中执行run方法
t1.start() # Thread-1
# 通过对象直接调用run方法，会在主线程中执行；所以需通过start间接去调用
t1.run() # MainThread

5多线程服务器

=====多线程服务器=======
import socket
from threading import Thread
class ConversationThread(Thread):
    def __init__(self, conversation, addr):
        super().__init__()
        self.conversation = conversation
        self.addr = addr
    def run(self):
        while True:
            message = self.conversation.recv(1024).decode('utf-8')
            print(self.addr, ': ' + message, sep='')

server = socket.socket()
server.bind(('10.7.187.149', 9001))
server.listen(512)
while True:
    conversation, addr = server.accept()
    # 给服务器发送请求的客户端建立的连接创建一个子线程。在子线程中去处理每个请求
    t = ConversationThread(conversation, addr)
    t.start()
 =======客户端  ======
import socket
client =socket.socket()
client.connect(('10.7.187.149', 9000))
while True:
    message=input('客户端：')
    client.send(message.encode('utf-8'))

6 join函数

线程对象.join() - 等待线程对象中的任务执行完成

from threading import Thread
import time,datetime,random
class Download(Thread):
    def __init__(self,film_name):
        super().__init__()
        self.film_name=film_name
    def run(self):
        print('开始下载：%s'%self.film_name)
        a=random.randint(5,12)
        time.sleep(a)
        print('%s开始结束'%self.film_name,'耗时%d秒'%a)
t1=Download('小黄人')
t2=Download('地心游记')
time1=time.time()
t1.start()
t2.start()
# t1 和t2中的任务都执行完成后才执行后面的代码
t1.join()
t2.join()

time2=time.time()
print('总共时间：',time2-time1)

7数据共享

threading中需要掌握的两个类：Thread,Lock；
Thread - 线程类(创建子线程)
Lock - 锁（创建锁对象）
混乱：当多个线程同时对同一个数据进行操作的时候，可能会出现数据混乱
多个线程对一个数据进行操作，一个线程将数据读出来，还没来得及存进去；
另一个线程又去读了，这个时候就可能会产生数据安全隐患。
解决方案就是加锁：加锁后，多线程并没有变成单线程；而是线程在加锁的位置等待数据存进去后再去取。

import time,threading
class Account:
    def __init__(self,balance,name):
        self.balance=balance
        self.name=name
        self.lock=threading.Lock() # 创建锁对象
    def save(self,num):
        """存钱"""
        # 加锁
        self.lock.acquire()
        print('开始存钱')
        old_balance=self.balance
        time.sleep(5)# 停留一段时间
       self.balance=num+old_balance
        print('存钱成功')
        # 解锁
        self.lock.release()
    def draw(self,num):
        # 加锁
        self.lock.acquire()
        """取钱"""
        print('开始取钱')
        old_balance = self.balance
         time.sleep(5)  # 停留一段时间
        self.balance = old_balance-num
        print('取钱成功')
        # 解锁
        self.lock.release()

account1=Account(1000,'李四')
t1=threading.Thread(target=account1.save,args=(1000,))
t2=threading.Thread(target=account1.draw,args=(500,))

t1.start()
t2.start()

t1.join()
t2.join()
print(account1.balance)

8

======使用json获取数据=======
import requests
from threading import Thread
def download(url: str):
"""下载函数"""
    image_data = requests.get(url).content
    file_name = url.split('/')[-1]
    with open('images/'+file_name, 'wb') as f:
        f.write(image_data)
1.下载接口对应的数据
 url = 'https://www.apiopen.top/satinApi?type=1&page=1'
 data_dict = requests.get(url).json()
 datas = data_dict['data']
 for dict1 in datas:
     # 拿到一个图片地址，就为它创建一个线程对象，用来在子线程中下载这张图片
     t = Thread(target=download, args=(dict1['profile_image'],))
      t.start()  
print('下载完成')

 ========== 使用正则获取数据========
import requests
from threading import Thread
def download(url: str):
    """下载函数"""
    image_data = requests.get(url).content
    file_name = url.split('/')[-1]
    with open('images/'+file_name, 'wb') as f:
        f.write(image_data)
# 使用正则获取数据
import re
url = 'https://www.apiopen.top/satinApi?type=1&page=1'
text = requests.get(url).text

all_profile_image = re.findall(r'"profile_image":"(.+?)",', text)
for image_url in all_profile_image:
    Thread(target=download, args=(image_url,)).start()