我的项目day07:celery相关知识点:celery的快速使用,celery包结构,celery异步任务,延迟任务,定时任务,django中使用celery,秒杀逻辑,双写一致性

目录标题

      • 一:celery的快速使用
          • 1.celery官网
          • 2.celery是独立的服务
          • 3.celery的使用
      • 二:celery包结构
          • 1.包结构
          • 2.使用步骤
      • 三:celery异步任务,延迟任务,定时任务
          • 1.异步任务
          • 2.延时任务
          • 3.定时任务
      • 四:django中使用celery
          • 1.使用步骤
      • 五:秒杀逻辑
          • 1.前端
          • 2.后端
      • 六:双写一致性
          • 1.接口加缓存
          • 2.如何解决双写一致性的问题
          • 3.celery定时任务实现双写一致性

一:celery的快速使用

1.celery官网

http://www.celeryproject.org/

2.celery是独立的服务
1. 可以不依赖于任何服务器,通过自身命令,启动服务
2.为其他服务提供异步操作:
	一个是项目服务,一个是celery服务,项目服务将需要异步处理的任务交给celery服务,celery就会在需要的时候,异步完成项目的需求
3.celery的使用
1.安装:pip3 install celery
2.使用步骤:
-写一个main.py:实例化得到app对象,写函数,任务,注册成celery的任务
-在别的程序中:提交任务到broker中:add.delay(3,4)
-启动worker,从broker中取任务执行,执行完放到backend中
	win:
        celery worker -A main -l info -P eventlet # 4.x及之前用这个 
        celery -A main worker -l info -P eventlet # 5.x及之后用这个
     lin, mac:
         celery worker -A main -l info
         celery -A main worker -l info
-再backend中查看任务执行的结果
	-通过代码查看:
    	from main import app 
        from celery.result import AsyncResult
        id = '7bef14a0-f83e-4901-b4d8-e47aaac09b39'
        if __name__ == '__main__':
            res = AsyncResult(id=id, app=app)
            if res.successful():
                result = res.get()
                print(result)
            elif res.failed():
                print('任务失败')
            elif res.status == 'PENDING':
                print('任务等待中被执行')
            elif res.status == 'RETRY':
                print('任务异常后正在重试')
            elif res.status == 'STARTED':
                print('任务已经开始被执行') 

二:celery包结构

1.包结构
项目:
    celery_task
        -__init__.py
        -celery.py
        -user_task.py
        -home_task.py
    add_task.py
    get_result.py
2.使用步骤
新建包:celery_task
在包中先建一个celery.py
在里面写app的初始化
在包里新建user_task.py 编写用户相关任务
在包里新建home_task.py 编写首页相关任务
其他程序,提交任务
启动worker,它可以先启动,在提交任务之前
	celery -A celery_task worker -l info -P eventlet

celery_task/celery.py

from celery import Celery

backend = 'redis://127.0.0.1:6379/1'
broker = 'redis://127.0.0.1:6379/0'
# 一定不要忘了include
app = Celery(__name__, broker=broker, backend=backend,include=['celery_task.home_task','celery_task.user_task'])

celery_task/home_task.py

from .celery import app
@app.task
def add(a, b):
    time.sleep(3)
    print('计算结果是:%s' % (a + b))
    return a + b

celery_task/user_task.py

import time
from .celery import app
@app.task
def send_sms(mobile, code):
    time.sleep(1)
    print('短信发送成功:%s,验证吗是%s' % (mobile, code))
    return True

add_task.py

from celery_task.user_task import send_sms
# 提交了一个发送短信异步任务
res=send_sms.delay('18723345455','9999')
print(res)  # 672237ce-c941-415e-9145-f31f90b94627

# 任务执行,要启动worker

# 查看任务执行的结果

get_result.py

# 查询执行完的结果
from celery_task.celery import app

from celery.result import AsyncResult

id = '672237ce-c941-415e-9145-f31f90b94627'
if __name__ == '__main__':
    res = AsyncResult(id=id, app=app)
    if res.successful():
        result = res.get()  #7
        print(result)
    elif res.failed():
        print('任务失败')
    elif res.status == 'PENDING':
        print('任务等待中被执行')
    elif res.status == 'RETRY':
        print('任务异常后正在重试')
    elif res.status == 'STARTED':
        print('任务已经开始被执行')

三:celery异步任务,延迟任务,定时任务

1.异步任务
任务.delay(参数,参数)
2.延时任务
任务.apply_async(args=[参数,参数],eta=时间对象(utc时间))
3.定时任务
 # 定时任务配置
        -1 app的配置文件中配置 
        	app.conf.beat_schedule = {
                'send_sms_task': {
                    'task': 'celery_task.user_task.send_sms',
                    'schedule': timedelta(seconds=5),
                    # 'schedule': crontab(hour=8, day_of_week=1),  # 每周一早八点
                    'args': ('1897334444', '7777'),
                },
                'add_task': {
                    'task': 'celery_task.home_task.add',
                    'schedule': crontab(hour=12, minute=10, day_of_week=3),  # 每周一早八点
                    'args': (10, 20),
                }
            }
        -2 启动worker :干活的人
        	celery -A celery_task worker -l info -P eventlet
        -3 启动beat :提交任务的人
        	celery -A celery_task beat -l info

四:django中使用celery

1.使用步骤
1.把写好的包复制到项目路径下
2.在包内的celery.py的上面加入代码
import os
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffy_api.settings.dev')
import django
django.setup()
3.在django的视图类中,导入,提交任务
4.启动worker, beat

五:秒杀逻辑

1.前端
1 秒杀按钮
2 事件:向后端秒杀接口发送请求,发送完立马起了一个定时任务,每个5s,向后端查看一下是否秒杀成功,如果秒杀没成功,定时任务继续执行,如果秒杀成功了,清空定时任务,弹窗告诉他
    handleClick() {
      this.$axios.get(this.$settings.BASE_URL + 'userinfo/seckill/').then(res => {
        if (res.data.code == 100) {
          let task_id = res.data.id
          this.$message({
            message: res.data.msg,
            type: 'error'
          });
          // 起个定时任务,每隔5s向后端查询一下是否秒杀成功
          let t = setInterval(() => {
            this.$axios.get(this.$settings.BASE_URL + 'userinfo/get_result/?id=' + task_id).then(
                res => {
                  if (res.data.code == 100 || res.data.code == 101) {  //秒杀结束了,要么成功,要么失败了
                    alert(res.data.msg)
                    // 销毁掉定时任务
                    clearInterval(t)
                  } else if (res.data.code == 102) {
                    //什么事都不干
                  }
                }
            )
          }, 5000)


        }
      })
    }
2.后端
1 秒杀接口
    	提交秒杀任务
        def seckill(request):
            # 提交秒杀任务
            res = seckill_task.delay()
            return JsonResponse({'code': 100, 'msg': '正在排队', 'id': str(res)})
    2 查询是否秒杀成功的接口
    	根据用户传入的id,查询任务是否成功
        def get_result(request):
            task_id = request.GET.get('id')
            res = AsyncResult(id=task_id, app=app)
            if res.successful():
                result = res.get()  # 7
                return JsonResponse({'code': 100, 'msg': str(result)})
            elif res.failed():
                print('任务失败')
                return JsonResponse({'code': 101, 'msg': '秒杀失败'})
            elif res.status == 'PENDING':
                print('任务等待中被执行')
                return JsonResponse({'code': 102, 'msg': '还在排队'})

六:双写一致性

1.接口加缓存
# 首页轮播图接口,加缓存
# 提交了接口的响应速度
# 提高并发量
class BannerView(GenericViewSet, CommonListModelMixin):
    queryset = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')[:settings.BANNER_COUNT]
    serializer_class = BannerSerializer

    def list(self, request, *args, **kwargs):
        result = cache.get('banner_list')
        if result:  # 缓存里有
            print('走了缓存,速度很快')
            return APIResponse(result=result)
        else:
            # 去数据库拿
            print('走了数据库,速度慢')
            res = super().list(request, *args, **kwargs)
            result = res.data.get('result')  # {code:100,msg:成功,result:[{},{}]}
            cache.set('banner_list', result)
            return res
2.如何解决双写一致性的问题
1.修改mysql数据库,删除缓存【缓存的修改是在后面】
2.修改数据库,修改缓存【缓存的修改实在后面】
3.定时更新缓存, 针对于实时性不是很高的接口,适合定时更新
3.celery定时任务实现双写一致性

home_tas.py

@app.task
def update_banner():
    # 更新缓存
    # 查询出现在轮播图的数据
    queryset = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')[:settings.BANNER_COUNT]
    ser = BannerSerializer(instance=queryset, many=True)
    # ser 中得图片,没有前面地址
    for item in ser.data:
        item['image'] = settings.HOST_URL + item['image']
    cache.set('banner_list', ser.data)
    return True

celery.py

app.conf.beat_schedule = {
    'update_banner': {
        'task': 'celery_task.home_task.update_banner',
        'schedule': timedelta(seconds=50),
        'args': (),
    }
}

步骤

启动django
启动worker
启动beat

第一次访问:走数据库查询,放入了缓存
以后访问都会走:缓存
一旦mysql数据改了,缓存可能不一致
我们定时更新,保持一致

你可能感兴趣的:(drf,vue,django,django,python,后端)