celery介绍

接口缓存

1 查询所有接口（带过滤）--》每次都要去查询，性能不高

2 一旦查出来，下次还用这个数据的话--数据存放在缓存中---》直接给

3 首页轮播图

class BannerView(GenericViewSet, APIListModelMixin):
    queryset = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')[
               0:settings.BANNER_COUNT]  # 过滤排序
    serializer_class = Bannerserializer

    # 接口缓存
    def list(self, request, *args, **kwargs):
        banner_list = cache.get('banner_list')
        if not banner_list:
            # 缓存中没有数据，走数据库
            res = super().list(request, *args, **kwargs)
            banner_list = res.data.get('results')  # 列表类型
            # 放到django的缓存中
            cache.set('banner_list', banner_list)
        return APIResponse(results=banner_list)

。

1.1带缓存的mixin类

class CacheAPIListModelMixin(ListModelMixin):
    cache_key = None

    def list(self, request, *args, **kwargs):
        assert self.cache_key, APIException('如果继承CacheAPIListModelMixin，必须要加类属性')
        # 1  先去缓存中取,根据key
        results = cache.get(self.cache_key)
        if not results:
            logger.info('走了数据库----')
            res = super().list(request, *args, **kwargs)
            results = res.data
            # 2  存入缓存中
            cache.set(self.cache_key, results)
        return APIResponse(results=results)

视图类 home.view

from utils.common_mixin import CacheAPIListModelMixin


class BannerView(GenericViewSet, CacheAPIListModelMixin):
    queryset = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')[:settings.BANNER_COUNT]
    serializer_class = Bannerserializer
    cache_key = 'banner_list'

.

加入缓存后存在问题

# 1 数据从缓存拿--》如果mysql中数据改了--》缓存中一直有数据---》不会做自动更新---》缓存中的数据和mysql中的数据--》不一致了

# 2 缓存不一致；双写一致性

# 3 解决这个问题：
    -1 增，改，删 mysql--》删缓存
    -2 增，改，删 mysql--》更新缓存
    -3 定时更新缓存--》会有延迟

。

。

celery介绍

 0。 celery:分布式异步任务框架，celery 芹菜，吉祥物是芹菜

 1。 celery 是一个灵活且可靠的，处理大量消息的分布式系统，可以在多个节点之间处理某个任务

 2。 celery 是一个专注于实时处理的任务队列，支持任务调度

 3。 celery 是开源的，有很多的使用者

 4。 celery 完全基于 Python 语言编写

 5。 所以 celery 本质上是一个分布式的异步任务调度框架，类似于 Apache 的 airflow

 6。 celery 只是用来调度任务的，但它本身并不具备存储任务的功能，而调度任务的时候肯定是要把任务存起来的。
　　因此要使用 celery 的话，还需要搭配一些具备存储、访问功能的工具，比如：消息队列、Redis缓存、数据库等等。官方推荐的是消息队列 RabbitMQ，我们使用 Redis 


### celery能做什么###
    1 定时任务
    2 异步任务
    3 延迟任务

1.2celery 使用场景

1 异步任务
    -一些耗时的操作可以交给celery异步执行，而不用等着程序处理完才知道结果。
    -视频转码、邮件发送、消息推送等等
2 定时任务
    -定时推送消息、定时爬取数据、定时统计数据等

3 延迟任务
    -提交任务后，等待一段时间再执行某个任务

1.3 Celery官网

# 1 开源地址（源码）
https://github.com/celery/celery
    
# 2  官网
https://docs.celeryq.dev/en/stable/
    
# 3 最新版本
Celery (5.4)

#4 python支持
Celery version 5.3 runs on
Python ❨3.8, 3.9, 3.10, 3.11❩

#5 Django支持
Celery 5.3.x supports Django 2.2 LTS or newer versions. Please use Celery 5.2.x for versions older than Django 2.2 or Celery 4.4.x if your Django version is older than 1.11

1.4 celery架构

# Celery 架构，它采用典型的生产者-消费者模式，主要由以下部分组成：

# 1 Celery Beat，任务调度器，Beat 进程会读取配置文件的内容，周期性地将配置中到期需要执行的任务发送给任务队列。

# 2 Producer：需要在队列中进行的任务，一般由用户、触发器或其他操作将任务入队，然后交由 workers 进行处理。调用了 Celery 提供的 API、函数或者装饰器而产生任务并交给任务队列处理的都是任务生产者。

# 3 Broker，即消息中间件，在这指任务队列本身，Celery 扮演生产者和消费者的角色，brokers 就是生产者和消费者存放/获取产品的地方（队列）。

# 4 Celery Worker，执行任务的消费者，从队列中取出任务并执行。通常会在多台服务器运行多个消费者来提高执行效率。

# 5 Result Backend：任务处理完后保存状态信息和结果，以供查询。Celery 默认已支持 Redis、RabbitMQ、MongoDB、Django ORM、SQLAlchemy 等方式。



实际应用中，用户从 Web 前端发起一个请求，我们只需要将请求所要处理的任务丢入任务队列 broker 中，由空闲的 worker 去处理任务即可，处理的结果会暂存在后台数据库 backend 中。
我们可以在一台机器或多台机器上同时起多个 worker 进程来实现分布式地并行处理任务。

 。

celery快速使用

1.1安装

# 0 创建Python项目

# 1 创建虚拟环境

# 2 安装celery pip install celery

# 3 安装redis（消息队列和结果存储使用redis） pip install redis

# 4 安装eventlet（win 平台，如果是mac，linux不需要） pip install eventlet

1.2快速使用

celery_demo.py--主文件

main.py

from celery import Celery
import time

# 创建一个Celery实例
broker = 'redis://127.0.0.1:6379/1'
backend = 'redis://127.0.0.1:6379/2'
app = Celery('celery_test', broker=broker, backend=backend)


# 定义任务
@app.task
def add(n, m):
    time.sleep(2)
    print('n+m的结果：%s' % (n + m))
    return n + m


@app.task
def send_email(mail='1922517453@qq.com'):
    print('模拟发送延迟--开始')
    time.sleep(2)
    print('模拟发送延迟--结束')
    return '邮件发送成功：%s' % mail

add_task.py--提交异步任务

# 提交任务文件
from main import add, send_email

# 同步执行任务
# res = add(3, 4)
# print(res)

# 2. 异步执行任务，提交到broker消息队列
res = add.delay(3, 4)
print(res)  # 返回任务id号 02358487-658e-4815-8f23-2da1ac919898

1.3查看提交的任务

 

1.4让worker执行任务

# 通过命令启动worker
# win启动
celery -A main worker -l info -P eventlet
# mac linux
celery -A main worker -l info 

 

1.5 结果存储查看结果

# 1 直接看redis 有数据

# 2 通过代码，拿到结果

from main import app
from celery.result import AsyncResult

id = '5a8d1d68-1963-4771-9889-839bd954a37b'
if __name__ == '__main__':
    result = AsyncResult(id=id, app=app)
    if result.successful():
        result = result.get()
        print(result)
    elif result.failed():
        print('任务失败')
    elif result.status == 'PENDING':
        print('任务等待中被执行')
    elif result.status == 'RETRY':
        print('任务异常后正在重试')
    elif result.status == 'STARTED':
        print('任务已经开始被执行')

。

。

。

celery包结构

 

celery.py

from celery import Celery
import time
broker = 'redis://127.0.0.1:6379/1'
backend = 'redis://127.0.0.1:6379/2'
# 1 创建app对象
app = Celery('app', broker=broker, backend=backend,include=['celery_task.order_task','celery_task.user_task'])

------------------------------------------------

user_tasks.py

from .celery import app
import time
# 用户相关任务
@app.task
def add(x,y):
    time.sleep(3)
    return x+y

--------------------------------------------------
order_task.py

from .celery import app
# 订单相关任务
# 下单成功，发送短信
@app.task
def send_sms(mobile,code):
    print(f'手机号：{mobile},下单成功')
    return True

-------------------------------------

4.2 提交任务add_task.py

from celery_task.order_task import send_sms

# 1  同步调用
# res=send_sms('111111',888)
# print(res)

# 2 提交到任务队列被 worker执行
res = send_sms.delay('18896982015', 9999)
print(res)  # 282fd101-1047-427e-a4d6-867c36ec70ee

查看任务结果get_result.py

 

from celery_task.celery import app
from celery.result import AsyncResult

id = '282fd101-1047-427e-a4d6-867c36ec70ee'
if __name__ == '__main__':
    result = AsyncResult(id=id, app=app)
    if result.successful():
        result = result.get()
        print(result)
    elif result.failed():
        print('任务失败')
    elif result.status == 'PENDING':
        print('任务等待中被执行')
    elif result.status == 'RETRY':
        print('任务异常后正在重试')
    elif result.status == 'STARTED':
        print('任务已经开始被执行')

启动worker

# 包所在目录下，启动worker

　　-celery -A celery_task worker -l debug -P eventlet

 

执行异步--延迟--定时

# 1 刚刚学的是：异步任务
    任务名.delay()
    
# 2 延迟任务
    任务名.apply_async
    from celery_task.user_task import add
    from datetime import datetime, timedelta
    # datetime.utcnow() 取utc时间---》默认使用utc时间--》修改配置文件做中国时区
    eta=datetime.utcnow() + timedelta(seconds=30)
    res=add.apply_async(args=[5,6],eta=eta)
    
# 3 定时任务：配置文件
    3.1 配置文件  在celery.py里面操作
    # 时区
    app.conf.timezone = 'Asia/Shanghai'
    # 是否使用UTC
    app.conf.enable_utc = False

    # 任务的定时配置
    from datetime import timedelta
    from celery.schedules import crontab
    app.conf.beat_schedule = {
        'add-task': {
            'task': 'celery_task.user_task.add',
            'schedule': timedelta(seconds=3),
            # 'schedule': crontab(hour=8, day_of_week=1),  # 每周一早八点
            'args': (300, 150),
        },
        'send-sms-task': {
            'task': 'celery_task.order_task.send_sms',
            # 'schedule': timedelta(seconds=30),
            'schedule': crontab(hour=11,minute=20),  # 每天11点20执行
            'args': ('189232222',888),
        },
    }
    3.2 启动beat
    celery -A celery_task beat -l debug
    3.3 启动worker

。

django中使用celery

通用方案

# 1 把之前写的celery包，放到项目根路径中

# 2 在视图函数中提交任务
# from libs.tx_sms import get_code,send_sms as sms
from celery_task.order_task import send_sms as sms1
from celery_task.user_task import add
class CeleryView(APIView):
    def get(self, request, *args, **kwargs):
        ## 1异步发送短信
        mobile=request.query_params.get('mobile')
        code=get_code()
        # 使用celery做异步，提交任务
        res=sms1.delay(mobile,code)
        return APIResponse(msg=f'短信已发送，{str(res)}')


        ## 2 异步计算
        # x=request.query_params.get('x')
        # y=request.query_params.get('y')
        # # res=add(x,y)# -->请求要等：3s多
        # res=add.delay(x,y)# -->请求直接返回
        # return APIResponse(msg=str(res))
        
# 3 启动worker
# 4 运行django，正常使用接口即可

======================================================
# 必须加这行代码，以后才能用django的配置
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffytest.settings.dev')

[celery官方方案(新)]

#### 1 安装模块
pip install Django==3.2.22
pip install celery
pip install redis
pip install eventlet  #在windows环境下需要安装eventlet包

### 2  在项目目录下新建celery.py

import os
import django
from celery import Celery
from django.conf import settings

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffytest.settings.dev')
django.setup()

app = Celery('celery_demo')
# 方案一：不用
# app.conf.update(
#     BROKER_URL='redis://127.0.0.1:6379/1',
#     # BACKEND配置，使用redis
#     CELERY_RESULT_BACKEND='redis://127.0.0.1:6379/2',
#     CELERY_ACCEPT_CONTENT=['json'],
#     CELERY_TASK_SERIALIZER='json',
#     # 结果序列化方案
#     CELERY_RESULT_SERIALIZER='json',
#     # 任务结果过期时间，秒
#     CELERY_TASK_RESULT_EXPIRES=60 * 60 * 24,
#     # 时区配置
#     CELERY_TIMEZONE='Asia/Shanghai',
# )

# 方案二：
app.config_from_object('django.conf:settings', namespace='CELERY')
# 自动去每个app中寻找tasks.py文件,作为celery的任务
app.autodiscover_tasks()
# app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)

### 3 在apps下的init中加入

from .celery1 import app as celery_app

__all__ = ('celery_app',)

 

###4.在配置文件中配置

# celery的配置
# broker配置，使用redis作为消息中间件
CELERY_BROKER_URL = 'redis://127.0.0.1:6379/1'
# 结果存储配置，使用redis
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/2'
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
# 结果序列化方案
CELERY_RESULT_SERIALIZER = 'json'
# 任务结果过期时间，秒
CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24,
# 时区配置
CELERY_TIMEZONE = 'Asia/Shanghai'

CELERY_BEAT_SCHEDULE = {
    'update_banner': {
        'task': 'home.tasks.add',
        'schedule': timedelta(seconds=5),
        # 'schedule': timedelta(minutes=3),
        # 这点要传值
        'args': (2, 4),
    },
}

。

在user.view中测试

from .tasks import send_email

class CeleryView(APIView):
    def get(self, request, *args, **kwargs):

    # 官方方案集成celery
        res = send_email.delay()
        return APIResponse(msg=f'邮件已经发送了:{str(res)}')

 

定时更新轮播图缓存

可能会存在的问题

# 1 轮播图加入了缓存---》

　　缓存和数据库数据可能不一致

　　 -缓存双写一致性

# 2 解决不一致问题

　　 -1 增删改属性---》删缓存

　　 -2 增删改属性---》修改缓存

　　 -3 定时更新--》会有延迟

# 3 咱们使用 定时更新，处理缓存双写一致性问题

解决办法

写一个celery任务-更新轮播图

home_task
 1 from home.models import Banner
from .celery import app
from django.core.cache import cache
from django.conf import settings
from home.serializer import Bannerserializer


@app.task
def update_banner():
    # 更新缓存数据
    # 1.查询所有轮播图
    queryset = Banner.objects.all().filter(is_delete=False, is_show=True).order_by('orders')[:settings.BANNER_COUNT]
    serializer = Bannerserializer(queryset, many=True)
    for item in serializer.data:
        item['image'] = settings.BACKEND_URL + item['image']
    cache.set('banner_list', serializer)
    return '轮播图缓存更新成功'

 

定时任务

import os

import django
from celery import Celery

# 必须加这行代码，以后才能用django的配置
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'luffytest.settings.dev')
django.setup()
broker = 'redis://127.0.0.1:6379/1'
backend = 'redis://127.0.0.1:6379/2'
# 1 创建app对象,include指定任务是哪些
app = Celery('app', broker=broker, backend=backend,
             include=['celery_task.order_task', 'celery_task.user_task', 'celery_task.home_task'])

# 定时任务
# print(app.conf)

# 时区
app.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
app.conf.enable_utc = False

# 任务的定时配置
from datetime import timedelta
from celery.schedules import crontab

app.conf.beat_schedule = {
    # 轮播图定时任务
    'update-banner-task': {
        'task': 'celery_task.home_task.update_banner',
        'schedule': timedelta(minutes=1),
        'args': (),
    }
    
}

。

。

。

补充：app.task和 shared_task区别

1 两个装饰器的区别

# @app.task(bind=True)装饰器：

这是Celery库中的装饰器，用于将函数注册为Celery任务。
bind=True指定任务函数的第一个参数为任务实例本身(通常命名为self)，允许您在任务函数内部访问任务实例的属性和方法。

# @shared_task(bind=True)装饰器：

这是Celery的另一个装饰器，用于将函数注册为共享任务（shared task）。
共享任务是一种特殊类型的任务，可以跨多个Celery应用程序共享和调用。
如果您的任务需要在多个Celery应用程序中共享，或者您希望使用共享任务的特性，那么可以考虑使用此装饰器。
 

#  使用建议

哪个装饰器更好取决于您的具体需求和使用情况:

如果您只是在单个Celery应用程序中定义和使用任务函数，那么@app.task(bind=True)装饰器可能更适合。

如果您需要共享任务或跨多个Celery应用程序使用任务，那么@shared_task(bind=True)装饰器可能更适合。

补充2：定时任务配置(app中任务文件名必须叫tasks)

。

。

。

admin配置定时任务

# 1 之前，定时任务都要在配置文件中配置，项目启动前，就定死了，后期不能改，也不能停

# 2 通过settings.py的配置可以实现定时任务的配置，做为实际项目中可能还是不够实用，更加工程化的做法是将定时任务的配置放到数据库里通过界面来配置。

# 3 Celery对此也提供了很好的支持，这需要安装django-celery-beat插件

#### 使用步骤
1 pip install django-celery-beat
2 app注册
    INSTALLED_APPS = [
    ....
    'django_celery_beat',
    ]
3 配置文件：屏蔽到原来的调度器
CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers.DatabaseScheduler'
4 设置时区
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_TZ = False


5 数据库迁移
python manage.py migrate django_celery_beat


6 启动woker和beat

#在两个控制台分别启动woker和beat
celery -A luffy_api.celery1 worker -l debug -P eventlet
celery -A luffy_api.celery1 beat -l debug

7 创建超级用户-访问admin的web管理端
http://127.0.0.1:8000/admin/login/

# 存在的问题
    - 周期性 ：不涉及到时区，正常用
    - 固定时间的：跟时区紧密相关
        -可能会有时区问题
        
        
# 通过接口，存某些表实现

 

 

 。

。

admin监视任务

在控制台监控任务执行情况，还不是很方便，最好是能够通过web界面看到任务的执行情况，如有多少任务在执行，有多少任务执行失败了等 这个Celery也是可以做到了，就是将任务执行结果写到数据库中，通过web界面显示出来。 这里要用到django-celery-results插件。 通过插件可以使用Django的orm作为结果存储，这样的好处在于我们可以直接通过django的数据查看到任务状态，同时为可以制定更多的操作

#### 步骤### 
## 1 安装django-celery-results

pip install django-celery-results


##2 配置settings.py，注册app

INSTALLED_APPS = (
...,
'django_celery_results',
)


## 3 修改backend配置，将Redis改为django-db

# BACKEND配置，使用redis
#CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/1'

# 使用使用django orm 作为结果存储
CELERY_RESULT_BACKEND = 'django-db'  #使用django orm 作为结果存储


## 4 迁移数据库

python manage.py migrate django_celery_results
# 可以看到创建了django_celery_results相关的表

## 5 admin 查看

# 6 后期，后台管理自己写，
    -可以直接使用django的orm取数据
    -也可以放到redis中，自己写接口处理

 。

。

Flower 监控celery任务

如果不想通django的管理界面监控任务的执行，还可以通过Flower插件来进行任务的监控。Flower的界面更加丰富，可以监控的信息更全

Flower 是一个用于监控和管理 Celery 集群的开源 Web 应用程序。它提供有关 Celery workers 和tasks状态的实时信息

# Flower可以：
1 实时监控celery的Events
    -查看任务进度和历史记录
    -查看任务详细信息（参数、开始时间、运行时间等）

2 远程操作
    -查看workers 状态和统计数据
    -关闭并重新启动workers 实例
    -控制工作池大小和自动缩放设置
    -查看和修改工作实例消耗的队列
    -查看当前正在运行的任务
    -查看计划任务（预计到达时间/倒计时）
    -查看保留和撤销的任务
    -应用时间和速率限制
    -撤销或终止任务

3 Broker 监控
    -查看所有 Celery 队列的统计信息

    
#### 使用步骤######

## 1 安装和启动

pip install flower

#2 启动
# 方式一：
celery -A luffytest flower --port-5555
#方式二
celery --broker=redis://127.0.0.1:6379/1 flower

        
#3 浏览器访问：
http://127.0.0.1:5555/

 必须启动worker和beat,

 。

。

任务异常自动告警

虽然可以通过界面来监控了，但是我们想要得更多，人不可能天天盯着界面看吧，如果能实现任务执行失败就自动发邮件告警就好了。这个Celery当然也是没有问题的。 通过钩子程序在异常的时候触发邮件通知

 tasks.py中加入

from celery import shared_task
import time
from celery import Task
from django.core.mail import send_mail
from django.conf import settings
# 成功失败邮件告警
class SendEmailTask(Task):
    def on_success(self, retval, task_id, args, kwargs):
        info = f'任务成功-- 任务id是:{task_id} , 参数是:{args} , 执行成功 !'
        send_mail('celery任务监控成功告警', info, settings.EMAIL_HOST_USER, ["616564099@qq.com",])

        print('------------成功')

    def on_failure(self, exc, task_id, args, kwargs, einfo):
        info = f'任务失败-- 任务id为:{task_id} , 参数为:{args} , 失败 ! 失败信息为: {exc}'
        send_mail('celery任务监控失败告警', info, settings.EMAIL_HOST_USER, ["616564099@qq.com",])
        print('------------失败')

    def on_retry(self, exc, task_id, args, kwargs, einfo):
        print(f'任务id位：:{task_id} , 参数为:{args} , 重试了 !  错误信息为: {exc}')


@shared_task(base=SendEmailTask, bind=True)
def add(a,b):
    time.sleep(1)
    return a+b


@shared_task()
def send_email(mail):
    print(f'给{mail}发送邮件了')
    return '成功'

。

django发送邮件

user.view

# django发送邮件，celery使用
from django.core.mail import send_mail as django_send_email
from django.conf import settings


class EmailView(APIView):
    def get(self, request, *args, **kwargs):
        to_user = request.query_params.get('to_user')
        django_send_email('邮件标题，非常重要', '内容：你好', settings.EMAIL_HOST_USER, [to_user, ])
        return APIResponse(msg=f'邮件发送:{str(to_user)}')

************************
dev配置
# 发送邮件
EMAIL_HOST = 'smtp.qq.com'  # 如果是 163 改成 smtp.163.com
EMAIL_PORT = 465
EMAIL_HOST_USER = 'xxx@qq.com'  # 帐号
EMAIL_HOST_PASSWORD = '邮箱授权码'  # 密码
DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
# 这样收到的邮件，收件人处就会这样显示
# DEFAULT_FROM_EMAIL = 'lqz<'306334678@qq.com>'
EMAIL_USE_SSL = True  # 使用ssl
# EMAIL_USE_TLS = False # 使用tls
# EMAIL_USE_SSL 和 EMAIL_USE_TLS 是互斥的，即只能有一个为 True

 。

。

异步秒杀方案

# 秒杀功能

　　 - qps要高：承载住很多用户1s内把功能完成

　　 -创建订单

　　 -扣减库存

　　 - 效率要高

# 同步秒杀

　　 -假设秒杀需要10s钟，项目并发量是3，总共5个商品要秒杀

　　 -10s内，只有3个人能进入到系统，并且开始秒杀

# 异步秒杀

　　 -假设秒杀需要10s钟，项目并发量是3，总共5个商品要秒杀 -使用异步，用户提交后，立马返回

　　 -10s内，可以响应很多很多用户提交秒杀任务：假设提交了100个用户 -这100个用户中只有5个成功

前端

<template>
  <div>
    <Header></Header>
    <div style="padding: 50px;margin-left: 100px">
      <h1>Go语言课程</h1>
      <img src="http://photo.liuqingzheng.top/2023%2002%2022%2021%2057%2011%20/image-20230222215707795.png"
           height="300px"
           width="300px">
      <br>
      <el-button type="danger" @click="handleSeckill" v-loading.fullscreen.lock="fullscreenLoading">秒杀课程</el-button>
    </div>


    <br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>


    <Footer></Footer>

  </div>
</template>


<script>
import Header from '@/components/Header'
import Footer from '@/components/Footer'

export default {
  name: "SckillView",
  data() {
    return {
      fullscreenLoading: false,
      task_id: '',
      t: null,
    }
  },
  methods: {
    // ##############同步秒杀##############
    // handleSeckill() {
    //   this.fullscreenLoading = true;
    //   this.$axios({
    //     url: 'http://127.0.0.1:8000/api/v1/user/seckill/seckill/',
    //     method: 'POST',
    //     data: {
    //       course_id: '99'
    //     }
    //   }).then(res => {
    //     this.fullscreenLoading = false;
    //     this.$message.success(res.data.msg)
    //   }).catch(res => {
    //     this.fullscreenLoading = false;
    //     this.$message.error(res)
    //   })
    // }
    // ##############同步秒杀##############


    // ##############异步秒杀##############
    handleSeckill() {
      this.fullscreenLoading = true;
      this.$axios({
        url: 'http://127.0.0.1:8000/api/v1/user/seckill/seckill/',
        method: 'POST',
        data: {
          course_id: '99'
        }
      }).then(res => {
        // 在排队，转圈的，还需要继续显示
        this.$message.success(res.data.msg)
        this.task_id = res.data.task_id
        // 继续发送请求---》查询是否秒杀成功：1 成功 2 没成功  3 秒杀任务还没执行
        // 启动定时任务，没隔1s，向后端发送一次请求
        this.t = setInterval(() => {
          this.$axios({
            url: 'http://127.0.0.1:8000/api/v1/user/seckill/get_result/',
            method: 'get',
            params: {
              task_id: this.task_id
            }
          }).then(res => {
            // 100 成功,success : 1 成功  0 失败  2 还没开始
            if (res.data.success == '1') {
              // 转圈框不显示
              this.fullscreenLoading = false;
              // 停止定时任务
              clearInterval(this.t)
              this.t = null
              this.$message.success(res.data.msg)

            } else if (res.data.success == '0') {
              // 转圈框不显示
              this.fullscreenLoading = false;
              // 停止定时任务
              clearInterval(this.t)
              this.t = null
              this.$message.error(res.data.msg)
            } else {
              // this.$message.error(res.msg)
              console.log(res.msg)
            }
          })
        }, 1000)

      }).catch(res => {
        this.fullscreenLoading = false;
        this.$message.error(res)
      })
    }
  },
  components: {
    Header, Footer
  }
}
</script>


<style scoped>

</style>

后端

注意：所有关于之前写的celery都要注释掉

views.py

# 秒杀
from celery_task.celery import app
from celery_task.user_task import seckill
from celery.result import AsyncResult

import random


class SeckillView(ViewSet):
    #### 同步操作，性能不高
    # @action(methods=['POST'], detail=False)
    # def seckill(self, request, *args, **kwargs):
    '''
    #1  取出传入的 课程id
    #2 查询课程 是否还有剩余          1s
        #2.1 有剩余，开始下单扣减库存  1s
        #2.2，在订单表中生成一条记录   2s
        #2.3  秒杀成功返回给前端
    #3 课程没有剩余，秒杀失败，返回给前端
    '''

    # course_id = request.data.get('course_id')
    # print('根据课程id：%s，查询课程是否还有剩余，耗时3s' % course_id)
    # time.sleep(1)
    # res = random.choice([True, False])
    # if res:  # 库存够
    #     print('扣减库存，耗时3s')
    #     time.sleep(1)
    #     print('下单，耗时4s')
    #     time.sleep(2)
    #     return APIResponse(msg='恭喜您秒到了')
    # else:
    #     return APIResponse(code=101, msg='库存不足，秒杀失败')

    #  异步提交任务
    @action(methods=['POST'], detail=False)
    def seckill(self, request, *args, **kwargs):
        course_id = request.data.get('course_id')
        task_id = seckill.delay(course_id)
        return APIResponse(msg='您正在排队', task_id=str(task_id))

    @action(methods=['GET'], detail=False)
    def get_result(self, request, *args, **kwargs):
        task_id = request.query_params.get('task_id')
        a = AsyncResult(id=task_id, app=app)
        if a.successful():
            result = a.get()  # True 和 False
            if result:
                return APIResponse(success='1', msg='秒杀成功')
            else:
                return APIResponse(success='0', msg='秒杀失败')
        elif a.status == 'PENDING':
            print('任务等待中被执行')
            return APIResponse(success='2', msg='任务等待中被执行')
        else:
            return APIResponse(success='3', msg='秒杀任务正在执行')

任务

@app.task
def seckill(course_id):
    print('根据课程id：%s，查询课程是否还有剩余，耗时2s' % course_id)
    time.sleep(2)
    res = random.choice([True, False])
    if res:  # 库存够
        print('扣减库存，耗时1s')
        time.sleep(1)
        print('下单，耗时2s')
        time.sleep(2)
        return True
    else:
        return False