celery介绍和安装、celery快速使用、celery包结构、celery执行异步任务、延迟任务、定时任务、django中使用celery
昨日回顾
# 1 登录注册前端
-登录
-手机验证码登录---》输入框输入手机号---》监听失去焦点事件---》手机号正则校验(js),查询手机号是否存在----》发送验证码的按钮可以点击---》点击发送验证码按钮---》ajax 发送验证码---》起了个定时任务---》手机收到了验证码，填入验证码框-----》点击登录按钮----》向后端发送登录ajax请求----》返回给前端token和username----》前端保存到cookie中----》子传父，关闭了登录模态框----》在Header.vue 取了一下token和username
-多方式登录---》输入用户名和密码后----》点击登录--》后端登录成功，返回username和token---》后面的同上
-注册
-输入手机号---》监听失去焦点事件---》手机号正则校验(js),查询手机号是否存在-如果不存在---》发送验证码的按钮可以点击---》点击发送验证码按钮---》ajax 发送验证码---》起了个定时任务---》手机收到了验证码，填入验证码框-----》填入密码---》点击注册---》调用注册接口完成注册----》子传父---》Register.vue---->显示出Login.vue
# 2 redis 介绍
-数据库，非关系型数据库，缓存数据库，key-value形式存储，数据都在内存中，有5大数据类型，速度非常快，数据操作是单线程，不存在并发安全的问题
-redis的缓存更新策略
-为什么这么快：
1 纯内存操作
2 高性能的网络模型 IO多路复用(epoll)
3 单线程，不存在线程间切换
-redis版本
7.x 最新
6.x 从它后，多进程，多线程架构
5.x及之前 单进程单线程架构
-进程：资源分配的最小单位，一个程序运行起来，可能一个进程，也可能多个进程
-线程：cpu调度的最小单位，遇到io操作，操作系统层面切换
-协程：单线程下的并发，程序层面控制，遇到io操作，切换到别的任务执行
# 3 安装redis
-mac 编译完成了，bin路径下 redis-server redis-cli
-linux 编译安装
-win 专门的安装包
一路下一步
-安装完成会有两个命令：启动服务端，启动客户端 cs架构的软件
-客户端和服务端在同一台机器上
-本地的客户端可以连接远程的服务器
-mysql 也是cs架构软件
-pymysql ：是mysql的客户端
-Navicate：是mysql客户端
-go语言操作mysql：是mysql客户端
-启动redis服务
-redis-server 指定配置文件
-使用服务启动
-客户端连接
-cmd中使用redis-cli
-图形化界面
-python的redis模块操作redis
# 4 python连接redis
-普通连接
-连接池连接:单例模式
-django 使用mysql连接池
# 5 redis 5大数据类型之字符串 value值是字符串
-get
-set
-strlen
-mset
-mget
-getrang
....
今日内容
-
celery介绍和安装
-
celery快速使用
-
celery包结构
-
celery 执行异步任务，延迟任务，定时任务
-
django中使用celery
1 celery介绍和安装
# Celery 是什么
-翻译过来的意思是 芹菜 的意思，跟芹菜没有什么关系
-框架：服务，python的框架，跟django无关
-能用来做什么
-1 异步任务
-2 定时任务
-3 延迟任务
理解celery的运行原理
"""
1）可以不依赖任何服务器，通过自身命令，启动服务
2）celery服务为为其他项目服务提供异步解决任务需求的
注：会有两个服务同时运行，一个是项目服务，一个是celery服务，项目服务将需要异步处理的任务交给celery服务，celery就会在需要时异步完成项目的需求
人是一个独立运行的服务 | 医院也是一个独立运行的服务
正常情况下，人可以完成所有健康情况的动作，不需要医院的参与；但当人生病时，就会被医院接收，解决人生病问题
人生病的处理方案交给医院来解决，所有人不生病时，医院独立运行，人生病时，医院就来解决人生病的需求
"""
celery架构（Broker，backend 都用redis）
- 1 任务中间件 Broker(中间件)，其他服务提交的异步任务，放在里面排队
-需要借助于第三方 redis rabbitmq
- 2 任务执行单元 worker 真正执行异步任务的进程
-celery提供的
- 3 结果存储 backend 结果存储，函数的返回结果，存到backend中
-需要借助于第三方：redis，mysql
使用场景
异步执行：解决耗时任务
延迟执行：解决延迟任务
定时执行：解决周期(周期)任务
celery 不支持win，通过eventlet支持在win上运行
2 celery快速使用
# 安装----》安装完成 会有一个执行文件 celery
pip install celery
win：pip install eventlet
2.1 快速使用
第一步
# 新建 main.py
from celery import Celery
# 提交异步任务，放在里面
broker = 'redis://127.0.0.1:6379/1'
# 执行完的结果，放在这里
backend = 'redis://127.0.0.1:6379/2'
app = Celery('test', broker=broker, backend=backend)
@app.task
def add(a, b):
import time
time.sleep(3)
print('-------', a + b)
return a + b
第二步
# 其他程序，提交任务
# 提交任务
from main import add
# 同步调用
# res = add(5, 6)
# print(res)
# 异步调用
res = add.delay(5, 6) # 原来add的参数，直接放在delay中传入即可
print(res) # 053a7b51-719c-49d9-8f68-3d5173cf6918
第三步：启动worker
# 启动worker
# 启动worker命令，win需要安装eventlet
win:
-4.x之前版本
celery worker -A main -l info -P eventlet
-4.x之后版本
celery -A main worker -l info -P eventlet
mac:
celery -A main worker -l info
第四步
worker会执行消息中间件中的任务，把结果存起来
第五步
咱们要看执行结果，拿到执行的结果
from main import app
from celery.result import AsyncResult
id = '7a928205-d6a2-4c68-aed0-6503fbade112'
if __name__ == '__main__':
a = AsyncResult(id=id, app=app)
if a.successful(): # 执行完了
result = a.get()
print(result)
elif a.failed():
print('任务失败')
elif a.status == 'PENDING':
print('任务等待中被执行')
elif a.status == 'RETRY':
print('任务异常后正在重试')
elif a.status == 'STARTED':
print('任务已经开始被执行')
3 celery包结构
project
├── celery_task # celery包
│ ├── __init__.py # 包文件
│ ├── celery.py # celery连接和配置相关文件，且名字必须叫celery.py
│ └── tasks.py # 所有任务函数
├── add_task.py # 添加任务
└── get_result.py # 获取结果
第一步
第一步：新建包 celery_task
# 在包下新建[必须叫celery]的py文件，celery.py 写代码
from celery import Celery
# 提交异步任务，放在里面
broker = 'redis://127.0.0.1:6379/1'
# 执行完的结果，放在这里
backend = 'redis://127.0.0.1:6379/2'
app = Celery('test', broker=broker, backend=backend, include=['celery_task.order_task', 'celery_task.user_task'])
# 任务有很多 有用户相关任务 有订单相关任务
第二步
第二步：在包内部，写task，任务异步任务
# order_task.py
from .celery import app
import time
@app.task
def add(a, b):
print('-----', a + b)
time.sleep(2)
return a + b
# user_task.py
from .celery import app
import time
@app.task
def send_sms(phone, code):
print("给%s发送短信成功，验证码为：%s" % (phone, code))
time.sleep(2)
return True
第三步
第三步：启动worker ，包所在目录下
celery -A celery_task worker -l info -P eventlet
第四步
第四步：其他程序 提交任务，被提交到中间件中，等待worker执行，因为worker启动了，就会被worker执行
from celery_task.user_task import send_sms
# 异步调用
res = send_sms.delay('19999', 8888)
print(res) # 2c13c65e-2839-4152-bed0-dad2255ef9f7
第五步
第五步：worker执行完，结果存到backend中
第六步
第六步：我们查看结构
from celery_task.celery import app
from celery.result import AsyncResult
id = '2c13c65e-2839-4152-bed0-dad2255ef9f7'
if __name__ == '__main__':
a = AsyncResult(id=id, app=app)
if a.successful(): # 执行完了
result = a.get() #
print(result)
elif a.failed():
print('任务失败')
elif a.status == 'PENDING':
print('任务等待中被执行')
elif a.status == 'RETRY':
print('任务异常后正在重试')
elif a.status == 'STARTED':
print('任务已经开始被执行')
4 celery 执行异步任务，延迟任务，定时任务
4.1 异步任务
# 异步任务
任务.delay(参数)
4.2 延迟任务
# 延迟任务
任务.apply_async(args=[参数],eta=时间对象)# 如果没有修改时区，需要使用utc时间
from celery_task.user_task import send_sms
# 延迟任务
# 需要传入时间对象
from datetime import datetime, timedelta
# 拿到utc时间 datetime.utcnow()
# 30秒之后的时间
eta = datetime.utcnow() + timedelta(seconds=30)
res1 = send_sms.delay('654321', '9999') # 立即异步执行
print(res1)
# 30秒之后执行这个任务
res2 = send_sms.apply_async(args=['123456', '8888'], eta=eta) # 延迟30秒执行
print(res2)
# 启动worker
4.3 定时任务
-需要启动beta和启动worker
-beat 定时提交任务的进程---》
配置在app.conf.beat_schedule的任务
-worker 执行任务的
# 使用步骤
# 第一步：在celery的py文件中写入
from datetime import timedelta
from celery.schedules import crontab
# 定时任务
# celery 的配置文件
# 时区
app.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
app.conf.enable_utc = False
# celery的配置文件
# 任务的定时配置
app.conf.beat_schedule = {
'send_sms': {
'task': 'celery_task.user_task.send_sms',
# 'schedule': timedelta(seconds=3), # 时间对象
# 'schedule': crontab(hour=8, day_of_week=1), # 每周一早八点
'schedule': crontab(hour=20, minute=15), # 20点15执行
'args': {'88888888', '6666'}
}
}
# 第二步 启动beat
celery -A celery_task beat -l info
# 第三步 启动worker
celery -A celery_task worker -l info -P eventlet
# 注意点：
1 启动命令的执行位置，如果是包结构，一定在包这一层
2 include=['celery_task.order_task'],路径从包名下开始导入，因为我们在包这层执行的命令
5 django中使用celery
# 补充：如果在公司中，只是做定时任务，还有一个更简单的框架
APSchedule：https://blog.csdn.net/qq_41341757/article/details/118759836
使用步骤
-1 把咱们写的包，复制到项目目录下
-luffy_api
-celery_task #celery的包路径
-luffy_api #源代码路径
-2 在使用提交异步任务的位置，导入使用即可
-视图函数中使用，导入任务
-任务.delay() # 提交任务
-3 启动worker，如果有定时任务，启动beat
-4 等待任务worker执行
-5 在视图函数中，查询任务执行的结果
5.1 秒杀功能
# 秒杀逻辑分析
1 前端秒杀按钮，用户点击---->发送ajax请求到后端
2 视图函数--->提交秒杀任务--->借助于celery，提交到中间件中了
3 当次秒杀的请求，就回去了，携带着任务id号在前端
4 前端开启定时任务，每隔3s钟，带着任务，向后端发送请求，查看是否秒杀成功
5 后端的情况
1 任务还在等待被执行---->返回给前端，前端继续每隔3s发送一次请求
2 任务执行完了，秒杀成功---->返回给前端，恭喜您秒杀成功---->关闭前端定时器
3 任务执行完了，秒杀失败---->返回给前端，秒杀失败---->关闭前端定时器
5.1.1 视图
#### 秒杀逻辑，CBV
from rest_framework.viewsets import ViewSet
from celery_task.order_task import sckill_task
from celery_task.celery import app
from celery.result import AsyncResult
class SckillView(ViewSet):
@action(methods=['GET'], detail=False)
def sckill(self, request):
a = request.query_params.get('id')
# 使用异步，提交一个秒杀任务
res = sckill_task.delay(a)
return APIResponse(task_id=res.id)
@action(methods=['GET'], detail=False)
def get_result(self, request):
task_id = request.query_params.get('task_id')
a = AsyncResult(id=task_id, app=app)
if a.successful():
result = a.get()
if result:
return APIResponse(msg='秒杀成功')
else:
return APIResponse(code=101, msg='秒杀失败')
elif a.status == 'PENDING':
print('任务等待中被执行')
return APIResponse(code=666, msg='还在秒杀中')
5.1.2 任务 order_task.py
# 秒杀任务
import random
import time
@app.task
def sckill_task(good_id):
# 生成订单，减库存，都要在一个事务中
print("商品%s：秒杀开始" % good_id)
# 这个过程，可能是1,2,3s中的任意一个
time.sleep(random.choice([6, 7, 9]))
print('商品%s秒杀结束' % good_id)
return random.choice([True, False])
5.1.3 前端Sckill.vue
<template>
<div>
<button @click="handleSckill">秒杀</button>
</div>
</template>
<script>
import Header from '@/components/Header';
import Banner from '@/components/Banner';
import Footer from '@/components/Footer';
export default {
name: 'Sckill',
data() {
return {
task_id: '',
t: null
}
},
methods: {
handleSckill() {
this.$axios.get(this.$settings.BASE_URL + '/user/sckill/sckill/?id=999').then(res => {
this.task_id = res.data.task_id
this.t = setInterval(() => {
this.$axios.get(this.$settings.BASE_URL + '/user/sckill/get_result/?task_id=' + this.task_id).then(res => {
if (res.data.code == 666) {
//如果秒杀任务还没执行，定时任务继续执行
console.log(res.data.msg)
} else {
// 秒杀结束，无论成功失败，这个定时任务都结束
clearInterval(this.t)
this.t = null
this.$message(res.data.msg)
}
})
}, 2000)
}).catch(res => {
})
}
}
}
</script>
5.2 django中使用celery
使用步骤
1 把咱们写的包，复制到项目目录下
-luffy_api
-celery_task #celery的包路径
celery.py # 一定不要忘了一句话
import os os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffy_api.settings.dev')
-luffy_api #源代码路径
2 在使用提交异步任务的位置，导入使用即可
-视图函数中使用，导入任务
-任务.delay() # 提交任务
3 启动worker，如果有定时任务，启动beat
4 等待任务被worker执行
5 在视图函数中，查询任务执行的结果
# 重点：celery中使用djagno，有时候，任务中会使用django的orm，缓存，表模型。。。。一定要加
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffy_api.settings.dev')
6 轮播图接口加缓存
# 1 网站首页被访问的频率很高，瞬间 1w个人在访问，首页的轮播图接口会执行1w次，1w次查询轮播图标的sql在执行，轮播图基本不变
# 2 想一种方式，让这1w个访问，效率更高一些，不查数据库了，直接走缓存--》redis--》效率高
# 3 现在的逻辑变成了
1 轮播图接口请求来了，先去缓存中看，如果有，直接返回
2 如果没有，查数据库，然后把轮播图数据，放到redis中，缓存起来
# 改接口
# 新的 list 加入缓存的轮播图接口
def list(self, request, *args, **kwargs):
# 查看缓存中有没有数据，如果没有 查数据库
banner_list = cache.get('banner_list')
if banner_list:
print('走了缓存')
return APIResponse(data=banner_list)
else:
print('走了数据库')
res = super().list(request, *args, **kwargs)
cache.set('banner_list',res.data)
return APIResponse(data=res.data)
7 双写一致性
# 加入缓存后，缓存中有数据，先去缓存拿，但是如果mysql中数据变了，缓存不会自动变化，出现数据不一致的问题
mysql 和 缓存数据库 数据不一致
# 双写一致性
写入mysql，redis没动，数据不一致存在问题
# 如何解决
1 修改数据，删除缓存
2 修改数据，更新缓存
3 定时更新缓存 ---》实时性差
# 定时任务
celery
7.1 首页轮播图定时更新
第一步
# 第一步：在celery配置定时任务
app.conf.beat_schedule = {
'update_banner': {
'task': 'celery_task.home_task.update_banner',
'schedule': crontab(hour=8, day_of_week=1), # 时间对象 每周一早八点更新
# 'schedule': timedelta(seconds=3), # 测试3秒一更新
}
}
第二步
# update_banner任务的代码
from .celery import app
from home.models import Banner
from home.serializer import BannerSerializer
from django.core.cache import cache
from django.conf import settings
@app.task
def update_banner():
# 只要这个任务一执行，就更新轮播图的缓存
banners = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')
ser = BannerSerializer(instance=banners, many=True)
for item in ser.data:
item['image'] = settings.BACKEND_URL + item['image']
print(ser.data)
cache.set('banner_list', ser.data) # 会出问题，轮播图地址显示不全
return True
第三步
启动worker
celery -A celery_task worker -l info -P eventlet
启动beat
celery -A celery_task beat -l info
补充
# 补充 字符编码重点梳理
1 ascii 英文字母大小写，数字，标点符号
-127 够了 1个字节 8个比特位[每个比特位只能放0或1]
2的8次方中变化 256种变化
-ab! 00001001 000010010 000010010
2 中国，表示中文
GBK编码：用两个字节 表示一个字符
2的16次方:65536
3 韩国，表示韩文
998 文
998 한
4 unicode编码 把世界上所有的象形文字都有个数字对应 4个字节表示一个字符
998 文
28893 한
5 unicode编码存储---》硬盘上---》ab文한 4个字节 4个字节 4个字节 4个字节
-utf-8 unicode编码 编码，可变长
a 一个字节
b 一个字节
文 两个字节
한 三个字节
1个字节 1个字节 两个字节 三个字节
0 真正的存储的值
00 真正的值 00 真正的值
000
