Welcome to kimi's blog

Celery

目录

Celery

celery介绍和安装

celery是框架，是python的框架，但跟django无关的。

作用

  1. 异步任务
  2. 定时任务
  3. 延迟任务

原理

  1. 可以不依赖任何服务器，通过自身命令，启动服务

  2. celery服务为为其他项目服务提供异步解决任务需求的

    注：会有两个服务同时运行，一个是项目服务，一个是celery服务，项目服务将需要异步处理的任务交给celery服务，celery就会在需要时异步完成项目的需求

celery架构

  1. 任务中间件---Broker(中间件)

    其他服务提交的异步任务，放在里面排队，需要借助于第三方 redis/rabbitmq

  2. 任务执行单元---worker

    真正执行异步任务的进程,是celery提供的，执行消息中间件中的任务(函数)

  3. 结果存储----backend

    结果存储，函数的返回结果，存到 backend中 ，需要借助于第三方 redis/mysql

使用场景

异步执行：解决耗时任务
延迟执行：解决延迟任务
定时执行：解决周期(周期)任务

# celery 不支持win，通过eventlet支持在win上运行

celery快速使用

  1. 安装celery---有一个可执行文件celery

    pip install celery
win：pip install eventlet
# celery 不支持win，通过eventlet支持在win上运行

# 流程
1.创建app + 任务
2.启动celery(app)服务
3.添加任务：手动添加，要自定义添加任务的脚本，右键执行脚本
4.获取结果：手动获取，要自定义获取任务的脚本，右键执行脚本

  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 # 注册app
def add(a, b):
    import time
    time.sleep(3)
    print('------',a + b)
    return a + b
2. s1.py其他程序---提交任务
res = add.delay(5,6)   #原来add的参数，直接放在delay中传入即可
print(res)  # 63ae0fca-f530-45b8-a038-849627839975

3. 启动workers
# 启动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
        
        
4.worker会执行消息中间件中的任务，把结果存起来

5. 要看执行结果，拿到执行的结果---get_result.py
    from main import app
    from celery.result import AsyncResult
    id = '51611be7-4914-4bd2-992d-749008e9c1a6'
    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('任务已经开始被执行')

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
from .celery import app
import time
@app.task
def add(a, b):
    print('-----', a + b)
    time.sleep(2)
    return a + b

# user_task
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_task包所在目录下再执行
	celery  -A celery_task  worker -l info -P eventlet
    
    
# 第四步：其他程序 提交任务，被提交到中间件中，等待worker执行，因为worker启动了，就会被worker执行
from celery_task import send_sms
res=send_sms.delay('1999999', 8888)
print(res)  # 7d39033c-4cc7-4af2-8d78-e62c277db183


# 第五步：worker执行完，结果存到backend中

# 第六步：我们查看结构
from celery_task import app
from celery.result import AsyncResult
id = '5f022486-20af-4ecd-b46a-d7755a0c7134'
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('任务已经开始被执行')

celery执行异步任务，延迟任务、定时任务

  1. 异步任务

    任务.delay(参数)

    from celery_task.user_task import send_msg
res = send_msg.delay('1999999', 8888)
print(res)

  2. 延迟任务

    任务.apply_asyn(args=[参数]，eta=时间对象) 如果没有修改时区，需要使用utc事件

    from celery_task.user_task import send_msg
# 延迟任务
# 需要传入时间对象
from datetime import datetime,timedelta
# 拿到utc时间   datetime.utcnow()
print(type(datetime.now()))  # <class 'datetime.datetime'>
print(datetime.now()-timedelta(days=3))  # 2023-03-06 14:54:29.821628

# 1分钟后之后的时间
eta = datetime.utcnow()+ timedelta(minutes=1)
# 1分钟后执行这个任务
res = send_msg.apply_async(args=['1999999', '8888'],eta=eta)
print(res)

  3. 定时任务

    需要启动beat和启动workerbeat

    定时提交任务的进程---》配置在app.conf.beat_schedule的任务

    worker 执行任务的

    # 第一步：在celery的py文件中写入
        app.conf.timezone = 'Asia/Shanghai'
        # 是否使用UTC
        app.conf.enable_utc = False
# celery的配置文件#####
        # 任务的定时配置
        app.conf.beat_schedule = {
            'send_sms': {
                'task': 'celery_task.user_task.send_msg',
                'schedule': timedelta(seconds=3),  # 时间对象
                # 'schedule': crontab(hour=8, day_of_week=1),  # 每周一早八点
                #'schedule': crontab(hour=9, minute=43),  # 每天9点43
                'args': ('18888888', '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'],路径从包名下开始导入，因为在包这层执行的命令

django中使用celery

  1. 只做定时任务，还有简介的框架APSchedule

    APSchedule链接：https://blog.csdn.net/qq_41341757/article/details/118759836

django中使用celery

  1. 包复制到项目目录下

    luffy_api
        celery_task # celery的包路径
        luffy_api  # 源代码路径

  2. 使用提交异步任务，导入使用即可

    视图函数中使用，导入任务
任务.delay()  # 提交任务

  3. 启动worker，有定时任务--启动beat

  4. 等待任务被worker执行

  5. 在视图函数中，查询任务执行的结果

注意：celery中使用djagno，有时候，任务中会使用django的orm，缓存celery表模型，一定要加os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffy_api.settings.dev')

案例---秒杀任务

# 秒杀逻辑分析
	1 前端秒杀按钮，用户点击---》发送ajax请求到后端
    2 视图函数---》提交秒杀任务---》借助于celery，提交到中间件中了
    3 当次秒杀的请求，就回去了，携带者任务id号在前端
    4 前端开启定时任务，每隔3s钟，带着任务，向后端发送请求，查看是否秒杀成功
    5 后端的情况
    	1 任务还在等待被执行----》返回给前端，前端继续每隔3s发送一次请求
        2 任务执行完了，秒杀成功了---》返回给前端，恭喜您秒杀成功--》关闭前端定时器
        3 任务执行完了，秒杀失败了---》返回给前端，秒杀失败--》关闭前端定时器

视图类

# 秒杀逻辑，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):
        good_id = request.query_params.get('id')
        # 使用异步，提交一个秒杀任务
        res = sckill_task.delay(good_id)
        print(res)

        return APIResponse(task_id=res.id)

    @action(methods=['GET'], detail=False)
    def get_result(self,request):
        task_id = request.query_params.get('task_id')
        asyncR = AsyncResult(id=task_id,app=app)
        if asyncR.successful:
            result = asyncR.get()
            if result:
                return APIResponse(msg='秒杀成功')
            else:
                return APIResponse(code=101,msg='秒杀失败')
        elif asyncR.status == 'PENDING':
            print('任务等待中被执行')
            return APIResponse(code=666,msg='还在秒杀中')
        else:
            return APIResponse()

任务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([4,6,7]))
    print('商品%s 秒杀结束' % good_id)
    return random.choice([True,False])

Sckill.vue

<template>
  <div class="sckill">
    <button @click="clickSckill">秒杀</button>

  </div>

</template>

<script>
import axios from "axios";
export default {
  name: "Sckill",
  data(){
    return{
      task_id:'',
      timeInterval1:null

    }
  },
  methods:{
    clickSckill(){
      // 向后端发送请求
      axios.get(this.$settings.BASE_URL+'/user/sckill/sckill/?id=1').then(res=>{
        this.task_id=res.data.task_id
        //开启定时器
        this.timeInterval1=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.timeInterval1)
              this.timeInterval1 = null
              this.$message(res.data.msg)
            }
          })
        },2000)
      }).catch(res=>{
        console.log('code不是200以内走的')
      })
    }
  },
}

</script>

<style scoped>

</style>

image

轮播图接口加缓存

当网站首页被访问的频率很高，比如1w个人在访问，首页的轮播图接口会执行1w次，1w次查询轮播图标的sql在执行，轮播图基本不变，如何解决访问1w次，不查数据库，效率会更高一些？

将接口的返回结果存在缓存数据库，当访问来了，直接去缓存数据库拿数据返回给前端，不走数据库，效率会更高
   1.轮播图接口请求来了，先去缓存中看，如果有，直接返回
   2.如果没有，查数据库，然后把轮播图数据，放到redis中，缓存起来
   
   # 改轮播图的接口
    # 加入缓存的轮播图接口
    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)  # 初始化原来的数据
            print(res)
            # 把序列化后的数据存到缓存中，redis中
            cache.set('banner_list',res.data)
        return APIResponse(data=res.data)  # {code:100,msg:成功，data=[{},{}]}

在轮播图加入缓存后，缓存中有数据，当请求来了先去缓存拿数据，但是如果mysql中数据改变了，而缓存不会自动变化，出现数据不一致的问题，如何解决？

引出了数据库与缓存数据不一致------这引出了双写一致性的问题

双写一致性

mysql数据变动了，但redis没动，导致数据不一致存在问题。如何解决？

1.修改数据，删除缓存
2.修改数据，更新缓存
3.定时更新缓存  ---》但实时性差

# 定时任务：celery

首页轮播图定时更新

如果改了数据库的数据，有request对象会自动添加前面的路径 http://127.0.0.1:8000,没有request对象需要我们手动加入。

# 第一步：在celery配置定时任务
app.conf.beat_schedule = {
    'update_banner': {
        'task': 'celery_task.home_task.update_banner',
        'schedule': timedelta(seconds=3),  # 时间对象
    },
}

# 第二步：启动worker，启动beat

# 第三步  在settings中配置
BACKEND_URL = 'http://127.0.0.1:8000'

# update_banner任务的代码
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']

    cache.set('banner_list', ser.data)  # 会出问题，轮播图地址显示不全
    return True
posted @ 2023-03-09 08:34  魔女宅急便  阅读(36)  评论(0)    收藏  举报
Title