简单fastapi和压测实例

原创 已于 2025-12-30 21:57:45 修改 · 189 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fastapi #adb

于 2025-12-30 21:55:47 首次发布

服务器

from fastapi import FastAPI, HTTPException
import pymysql
from dbutils.pooled_db import PooledDB
from pydantic import BaseModel, Field
from typing import List, Optional, Dict

# 1. 初始化FastAPI应用实例
app = FastAPI(
    title="Shop数据库用户管理接口",
    description="支持查询所有用户、插入单条用户数据",
    version="2.0.0"
)

# 2. 配置MySQL连接参数（与原有配置一致）
MYSQL_CONFIG = {
    'host': 'localhost',
    'port': 3306,
    'user': 'root',
    'password': '666',
    'database': 'shop',
    'charset': 'utf8mb4'
}

# 3. 初始化数据库连接池（全局唯一，仅启动时创建一次）
POOL = PooledDB(
    creator=pymysql,  # 指定使用的数据库驱动
    **MYSQL_CONFIG,  # 传入MySQL连接参数
    maxconnections=10,  # 连接池最大连接数（根据业务调整）
    mincached=2,  # 初始化时，连接池中至少创建的空闲连接数
    maxcached=5,  # 连接池中最多缓存的空闲连接数
    maxusage=None,  # 每个连接最多被使用的次数（None表示无限制）
    blocking=True  # 当连接池无可用连接时，是否阻塞等待（True=等待，False=直接报错）
)


# 4. 定义数据模型（请求/响应）
class UserCreateRequest(BaseModel):
    """
    插入用户的请求数据模型（参数校验）
    """
    name: str = Field(..., min_length=1, max_length=50, description="用户名，不能为空，长度1-50")


class UserInfo(BaseModel):
    """
    用户信息响应模型
    """
    id: Optional[int] = None
    name: Optional[str] = None

    class Config:
        orm_mode = True


# 5. 核心工具函数（查询+插入）
def get_all_users_from_mysql() -> List[Dict]:
    """
    从连接池获取连接，查询users表所有数据，返回格式化的字典列表
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标（指定DictCursor，返回字典格式）
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

        # 执行查询
        sql = "SELECT * FROM users;"
        cursor.execute(sql)

        # 获取所有结果
        all_results = cursor.fetchall()

        return all_results

    except pymysql.Error as e:
        raise Exception(f"数据库查询失败：{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()


def insert_one_user_to_mysql(user_name: str) -> Dict:
    """
    从连接池获取连接，插入一条用户数据到users表，返回插入后的用户信息（含自增id）
    开启事务保障，避免数据插入异常
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标（普通游标，用于获取自增id）
        cursor = conn.cursor()

        # 定义插入SQL（使用参数化查询，避免SQL注入）
        insert_sql = "INSERT INTO users (name) VALUES (%s);"
        # 执行插入（传入参数元组，与SQL中的%s对应）
        affected_rows = cursor.execute(insert_sql, (user_name,))

        # 提交事务（关键：插入/更新/删除操作必须提交事务才会生效）
        conn.commit()

        # 获取插入数据的自增id
        insert_id = cursor.lastrowid
        # 查询插入后的完整用户信息，用于返回
        select_sql = "SELECT * FROM users WHERE id = %s;"
        cursor.execute(select_sql, (insert_id,))
        inserted_user = cursor.fetchone()

        # 转换为字典格式（与查询接口返回格式一致）
        if inserted_user:
            fields = [desc[0] for desc in cursor.description]
            user_dict = dict(zip(fields, inserted_user))
            return user_dict
        else:
            raise Exception("插入成功，但未查询到该用户数据")

    except pymysql.Error as e:
        # 回滚事务（插入失败时，撤销所有未提交的操作）
        if conn:
            conn.rollback()
        raise Exception(f"数据库插入失败：{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()


# 6. 定义FastAPI接口（查询+插入）
@app.get(
    "/api/shop/users",
    summary="查询shop库users表所有数据",
    response_description="返回users表的所有用户信息（含字段名）",
    response_model=List[UserInfo]
)
async def get_all_users():
    try:
        user_list = get_all_users_from_mysql()
        if not user_list:
            return []
        return user_list
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.post(
    "/api/shop/users",
    summary="插入一条用户数据到shop库users表",
    response_description="返回插入成功后的用户完整信息（含自增id）",
    response_model=UserInfo,
    status_code=201  # 201 Created：表示资源创建成功，符合RESTful规范
)
async def create_one_user(user_request: UserCreateRequest):
    try:
        # 调用插入工具函数，传入校验后的用户名
        inserted_user = insert_one_user_to_mysql(user_name=user_request.name)
        return inserted_user
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


# 7. 运行服务器
if __name__ == "__main__":
    import uvicorn

    uvicorn.run(
        app="__main__:app",
        host="0.0.0.0",
        port=8000,
        reload=True
    )

压测程序

import requests
import threading
import time
from datetime import datetime
from typing import List, Dict

# ---------------------- 压测配置项（可根据需求修改） ----------------------
TARGET_URL = "http://localhost:8000/api/shop/users"  # 你的FastAPI接口地址
CONCURRENT_THREADS = 5  # 并发线程数（模拟20个同时请求的用户）
TOTAL_REQUESTS_PER_THREAD = 50  # 每个线程发送的请求数
TIMEOUT = 10  # 单个请求超时时间（秒）

# ---------------------- 全局统计变量（线程安全） ----------------------
total_success = 0
total_failure = 0
response_times: List[float] = []
lock = threading.Lock()  # 线程锁，保证统计变量修改的安全性

def send_requests(thread_id: int) -> None:
    """
    单个线程的请求发送逻辑：循环发送指定数量的请求，并记录结果
    """
    global total_success, total_failure, response_times
    session = requests.Session()  # 每个线程创建一个Session，复用连接，提升效率

    for req_id in range(1, TOTAL_REQUESTS_PER_THREAD + 1):
        try:
            # 记录请求开始时间
            start_time = time.perf_counter()
            # 发送GET请求
            response = session.get(
                url=TARGET_URL,
                timeout=TIMEOUT
            )
            # 记录请求结束时间
            end_time = time.perf_counter()
            response_time = (end_time - start_time) * 1000  # 转换为毫秒

            # 验证请求是否成功（响应状态码200）
            if response.status_code == 200:
                with lock:  # 加锁修改全局变量，避免线程冲突
                    total_success += 1
                    response_times.append(response_time)
                print(f"[线程{thread_id}] 请求{req_id} 成功 | 响应时间：{response_time:.2f}ms | 响应状态码：{response.status_code}")
            else:
                with lock:
                    total_failure += 1
                print(f"[线程{thread_id}] 请求{req_id} 失败 | 响应状态码：{response.status_code}")

            print(total_success)
        except Exception as e:
            with lock:
                total_failure += 1
            print(f"[线程{thread_id}] 请求{req_id} 异常 | 错误信息：{str(e)}")

def run_benchmark() -> None:
    """
    启动压测：创建并启动所有线程，等待所有线程执行完成，输出统计结果
    """
    start_time = datetime.now()
    print("=" * 80)
    print(f"压测开始时间：{start_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"目标接口：{TARGET_URL}")
    print(f"并发线程数：{CONCURRENT_THREADS}")
    print(f"每个线程请求数：{TOTAL_REQUESTS_PER_THREAD}")
    print(f"总请求数：{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print("=" * 80 + "\n")

    # 创建线程列表
    threads: List[threading.Thread] = []
    for thread_id in range(1, CONCURRENT_THREADS + 1):
        thread = threading.Thread(
            target=send_requests,
            args=(thread_id,),
            name=f"Benchmark-Thread-{thread_id}"
        )
        threads.append(thread)
        thread.start()  # 启动线程

    # 等待所有线程执行完成
    for thread in threads:
        thread.join()

    # 计算统计结果
    end_time = datetime.now()
    total_duration = (end_time - start_time).total_seconds()
    avg_response_time = sum(response_times) / len(response_times) if response_times else 0
    qps = total_success / total_duration if total_duration > 0 else 0  # 每秒查询率（QPS）

    # 输出最终统计结果
    print("\n" + "=" * 80)
    print(f"压测结束时间：{end_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"总耗时：{total_duration:.2f} 秒")
    print(f"总请求数：{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print(f"成功请求数：{total_success}")
    print(f"失败请求数：{total_failure}")
    print(f"成功率：{(total_success / (total_success + total_failure) * 100):.2f}%" if (total_success + total_failure) > 0 else "成功率：0%")
    print(f"平均响应时间：{avg_response_time:.2f} ms")
    print(f"QPS（每秒查询率）：{qps:.2f}")
    print("=" * 80)

if __name__ == "__main__":
    run_benchmark()

概述

包含两份核心代码的详细说明：FastAPI用户管理接口（后端服务） 和 Python多线程接口压测工具（前端压测），涵盖代码功能、结构解析、使用指南、注意事项等内容，便于开发、测试、运维人员理解和使用。

第一部分：FastAPI用户管理接口（后端服务）

1. 代码核心功能

该代码实现了一个基于FastAPI框架的轻量级用户管理后端服务，依托dbutils连接池操作MySQL数据库shop的users表，提供两大核心接口：

  • GET /api/shop/users：查询users表所有用户数据，返回结构化用户列表
  • POST /api/shop/users：插入一条用户数据到users表，返回插入后的完整用户信息（含自增ID）
  • 附加能力：参数校验、SQL注入防护、事务保障、异常处理、自动生成交互式接口文档

2. 依赖环境说明

依赖库版本要求核心作用
fastapi>=0.95.0构建高性能RESTful API，提供接口路由、响应模型、自动文档等能力
uvicorn>=0.22.0FastAPI官方推荐ASGI服务器，用于运行后端服务
pymysql>=1.0.0MySQL数据库Python驱动，实现数据库连接与SQL执行
dbutils>=3.1.0提供数据库连接池功能，复用连接、提升并发访问效率
pydantic>=2.0.0数据模型定义与参数校验，保障请求数据合法性

3. 代码结构逐段解析

3.1 初始化与配置模块
from fastapi import FastAPI, HTTPException
import pymysql
from dbutils.pooled_db import PooledDB
from pydantic import BaseModel, Field
from typing import List, Optional, Dict

# 1. 初始化FastAPI应用实例
app = FastAPI(
    title="Shop数据库用户管理接口",
    description="支持查询所有用户、插入单条用户数据",
    version="2.0.0"
)

# 2. 配置MySQL连接参数（与原有配置一致）
MYSQL_CONFIG = {
    'host': 'localhost',
    'port': 3306,
    'user': 'root',
    'password': '666',
    'database': 'shop',
    'charset': 'utf8mb4'
}

# 3. 初始化数据库连接池（全局唯一，仅启动时创建一次）
POOL = PooledDB(
    creator=pymysql,  # 指定使用的数据库驱动
    **MYSQL_CONFIG,  # 传入MySQL连接参数
    maxconnections=10,  # 连接池最大连接数（根据业务调整）
    mincached=2,  # 初始化时，连接池中至少创建的空闲连接数
    maxcached=5,  # 连接池中最多缓存的空闲连接数
    maxusage=None,  # 每个连接最多被使用的次数（None表示无限制）
    blocking=True  # 当连接池无可用连接时，是否阻塞等待（True=等待，False=直接报错）
)
  • 核心说明：
    1. FastAPI实例初始化时配置了文档元信息，访问http://localhost:8000/docs可查看交互式接口文档
    2. MYSQL_CONFIG需与实际MySQL环境匹配，charset=utf8mb4支持全量中文与特殊字符
    3. 连接池POOL为全局单例，避免频繁创建/关闭数据库连接，提升并发性能；blocking=True保证高并发下连接获取的稳定性（无可用连接时等待，而非直接报错）
3.2 数据模型定义模块
class UserCreateRequest(BaseModel):
    """
    插入用户的请求数据模型（参数校验）
    """
    name: str = Field(..., min_length=1, max_length=50, description="用户名，不能为空，长度1-50")

class UserInfo(BaseModel):
    """
    用户信息响应模型
    """
    id: Optional[int] = None
    name: Optional[str] = None

    class Config:
        orm_mode = True
  • 核心说明：
    1. UserCreateRequest：用于POST接口的请求体校验，Field约束name为必填、非空、长度1-50，不符合约束时自动返回422错误
    2. UserInfo：用于接口响应数据格式化，统一返回id和name字段；orm_mode=True支持将数据库查询结果（字典/元组）转换为模型实例
    3. 依赖pydantic实现自动校验与序列化，无需手动编写校验逻辑
3.3 数据库操作工具函数
3.3.1 全量用户查询函数 get_all_users_from_mysql
def get_all_users_from_mysql() -> List[Dict]:
    """
    从连接池获取连接，查询users表所有数据，返回格式化的字典列表
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标（指定DictCursor，返回字典格式）
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        
        # 执行查询
        sql = "SELECT * FROM users;"
        cursor.execute(sql)
        
        # 获取所有结果
        all_results = cursor.fetchall()
        
        return all_results

    except pymysql.Error as e:
        raise Exception(f"数据库查询失败：{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()
  • 核心说明：
    1. 采用try-except-finally结构，保证游标关闭和连接归还（即使查询异常，也不会导致连接泄露）
    2. DictCursor游标返回字典格式结果（含字段名），便于后续接口返回结构化数据
    3. 连接从连接池获取（POOL.connection()），使用完毕后通过conn.close()归还到连接池（非真正关闭连接）
3.3.2 单条用户插入函数 insert_one_user_to_mysql
def insert_one_user_to_mysql(user_name: str) -> Dict:
    """
    从连接池获取连接，插入一条用户数据到users表，返回插入后的用户信息（含自增id）
    开启事务保障，避免数据插入异常
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标（普通游标，用于获取自增id）
        cursor = conn.cursor()
        
        # 定义插入SQL（使用参数化查询，避免SQL注入）
        insert_sql = "INSERT INTO users (name) VALUES (%s);"
        # 执行插入（传入参数元组，与SQL中的%s对应）
        affected_rows = cursor.execute(insert_sql, (user_name,))
        
        # 提交事务（关键：插入/更新/删除操作必须提交事务才会生效）
        conn.commit()
        
        # 获取插入数据的自增id
        insert_id = cursor.lastrowid
        # 查询插入后的完整用户信息，用于返回
        select_sql = "SELECT * FROM users WHERE id = %s;"
        cursor.execute(select_sql, (insert_id,))
        inserted_user = cursor.fetchone()
        
        # 转换为字典格式（与查询接口返回格式一致）
        if inserted_user:
            fields = [desc[0] for desc in cursor.description]
            user_dict = dict(zip(fields, inserted_user))
            return user_dict
        else:
            raise Exception("插入成功，但未查询到该用户数据")

    except pymysql.Error as e:
        # 回滚事务（插入失败时，撤销所有未提交的操作）
        if conn:
            conn.rollback()
        raise Exception(f"数据库插入失败：{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()
  • 核心说明：
    1. 事务保障：conn.commit()提交事务（插入操作生效），异常时conn.rollback()回滚事务（避免脏数据）
    2. 防SQL注入：采用参数化查询（%s占位符），参数通过元组传入，避免字符串拼接带来的注入风险
    3. cursor.lastrowid获取插入数据的自增ID（要求users表id字段为AUTO_INCREMENT）
    4. 插入后查询完整用户信息，保证返回数据与查询接口格式一致，提升接口易用性
3.4 接口定义模块
3.4.1 全量用户查询接口 GET /api/shop/users
@app.get(
    "/api/shop/users",
    summary="查询shop库users表所有数据",
    response_description="返回users表的所有用户信息（含字段名）",
    response_model=List[UserInfo]
)
async def get_all_users():
    try:
        user_list = get_all_users_from_mysql()
        if not user_list:
            return []
        return user_list
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
  • 核心说明：
    1. @app.get注解定义GET请求路由，response_model=List[UserInfo]约束返回数据格式为UserInfo模型列表
    2. 异常处理：捕获数据库查询异常，返回500状态码和详细错误信息，便于问题排查
    3. 异步函数（async）：适配FastAPI的异步架构，提升高并发下的响应性能（实际数据库操作为同步，可后续优化为异步驱动）
3.4.2 单条用户插入接口 POST /api/shop/users
@app.post(
    "/api/shop/users",
    summary="插入一条用户数据到shop库users表",
    response_description="返回插入成功后的用户完整信息（含自增id）",
    response_model=UserInfo,
    status_code=201  # 201 Created：表示资源创建成功，符合RESTful规范
)
async def create_one_user(user_request: UserCreateRequest):
    try:
        # 调用插入工具函数，传入校验后的用户名
        inserted_user = insert_one_user_to_mysql(user_name=user_request.name)
        return inserted_user
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
  • 核心说明：
    1. @app.post注解定义POST请求路由，status_code=201符合RESTful规范（资源创建成功）
    2. user_request: UserCreateRequest自动解析请求体并完成参数校验，校验失败返回422错误
    3. 传入校验后的user_request.name到插入函数，保证数据库接收的是合法数据
3.5 服务运行模块
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        app="__main__:app",
        host="0.0.0.0",
        port=8000,
        reload=True
    )
  • 核心说明：
    1. 采用uvicorn运行FastAPI应用，host="0.0.0.0"允许局域网内其他设备访问，port=8000为服务端口
    2. reload=True开启热重载（开发环境专用），代码修改后自动重启服务，无需手动重启
    3. 生产环境建议关闭reload，并配置workers（多进程）提升并发能力

4. 使用指南

4.1 前置准备
  1. 安装依赖：pip install fastapi uvicorn pymysql dbutils pydantic
  2. 配置MySQL环境：
    • 启动MySQL服务，创建数据库shop：CREATE DATABASE IF NOT EXISTS shop DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
    • 创建users表：
      CREATE TABLE IF NOT EXISTS users (
    id INT PRIMARY KEY AUTO_INCREMENT COMMENT '自增用户ID',
    name VARCHAR(50) NOT NULL COMMENT '用户名',
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';
    • 修改MYSQL_CONFIG中的user、password为实际MySQL账号密码
4.2 启动服务
  1. 将代码保存为user_service.py
  2. 运行命令：python user_service.py（或uvicorn user_service:app --host 0.0.0.0 --port 8000 --reload）
  3. 服务启动成功标志：控制台输出Application startup complete.
4.3 接口调用与调试
方式1：交互式接口文档（推荐）
  • 访问http://localhost:8000/docs，进入FastAPI自动生成的Swagger文档
  • 对于GET /api/shop/users：点击「Try it out」→「Execute」，即可查看响应结果
  • 对于POST /api/shop/users：点击「Try it out」，填写请求体（如{"name": "张三"}）→「Execute」，查看插入结果
方式2：curl命令调用
# 查询所有用户
curl -X GET "http://localhost:8000/api/shop/users" -H "Content-Type: application/json"

# 插入一条用户数据
curl -X POST "http://localhost:8000/api/shop/users" -H "Content-Type: application/json" -d "{\"name\": \"李四\"}"
方式3：第三方工具（Postman/Insomnia）
  • 配置请求方法、地址、请求头（Content-Type: application/json）和请求体，发送请求即可

5. 常见问题排查

问题现象可能原因解决方案
服务启动失败，提示“Access denied for user ‘root’@‘localhost’”MySQL账号密码错误修正MYSQL_CONFIG中的user、password
接口返回500，提示“数据库查询失败：1049 (42000): Unknown database ‘shop’”未创建shop数据库执行创建数据库的SQL语句
POST接口返回422，提示“field required”请求体缺少name字段或字段名拼写错误确保请求体包含name字段，字段名拼写正确
POST接口插入成功，但返回无idusers表id字段未设置为自增主键修改users表，将id字段设置为AUTO_INCREMENT
高并发下接口返回500，提示“Too many connections”MySQL最大连接数不足或连接池配置过小1. 增大MySQL最大连接数；2. 调大POOL的maxconnections参数

第二部分：Python多线程接口压测工具

1. 代码核心功能

该代码是一款轻量级的多线程接口压测工具，专门针对GET /api/shop/users接口进行压测，实现以下功能：

  • 模拟多线程并发请求（可配置并发线程数）
  • 每个线程发送指定数量的请求（可配置单线程请求数）
  • 记录请求成功率、失败率、响应时间（毫秒级）
  • 计算并输出压测汇总数据（总耗时、QPS、平均响应时间）
  • 线程安全的统计计数，避免并发修改数据冲突
  • 实时打印单个请求的执行结果，便于实时监控

2. 依赖环境说明

依赖库版本要求核心作用
requests>=2.28.0发送HTTP请求，获取接口响应结果
threading内置模块实现多线程并发，模拟高并发场景
time内置模块记录请求开始/结束时间，计算响应时间
datetime内置模块记录压测开始/结束时间，格式化时间输出
typing内置模块类型注解，提升代码可读性和可维护性

3. 代码结构逐段解析

3.1 压测配置项模块
import requests
import threading
import time
from datetime import datetime
from typing import List, Dict

# ---------------------- 压测配置项（可根据需求修改） ----------------------
TARGET_URL = "http://localhost:8000/api/shop/users"  # 你的FastAPI接口地址
CONCURRENT_THREADS = 5  # 并发线程数（模拟20个同时请求的用户）
TOTAL_REQUESTS_PER_THREAD = 50  # 每个线程发送的请求数
TIMEOUT = 10  # 单个请求超时时间（秒）
  • 核心说明：
    1. 配置项集中管理，便于用户根据实际场景修改，无需改动核心逻辑
    2. TARGET_URL：目标压测接口地址，需与FastAPI服务地址保持一致
    3. CONCURRENT_THREADS：并发线程数，模拟多个用户同时发起请求（建议根据服务器性能调整，避免过度压测）
    4. TOTAL_REQUESTS_PER_THREAD：单个线程发送的请求总数，总请求数=并发线程数×单线程请求数
    5. TIMEOUT：单个请求的超时时间，超过该时间未响应则判定为请求异常
3.2 全局统计变量与线程锁模块
# ---------------------- 全局统计变量（线程安全） ----------------------
total_success = 0
total_failure = 0
response_times: List[float] = []
lock = threading.Lock()  # 线程锁，保证统计变量修改的安全性
  • 核心说明：
    1. 全局统计变量：
      • total_success：成功请求总数（响应状态码200）
      • total_failure：失败请求总数（非200状态码+请求异常）
      • response_times：所有成功请求的响应时间列表（用于计算平均响应时间）
    2. threading.Lock()：创建线程锁，解决多线程并发修改全局变量时的数据竞争问题（确保同一时间只有一个线程修改全局变量，避免数据统计错误）
3.3 单个线程请求发送函数 send_requests
def send_requests(thread_id: int) -> None:
    """
    单个线程的请求发送逻辑：循环发送指定数量的请求，并记录结果
    """
    global total_success, total_failure, response_times
    session = requests.Session()  # 每个线程创建一个Session，复用连接，提升效率

    for req_id in range(1, TOTAL_REQUESTS_PER_THREAD + 1):
        try:
            # 记录请求开始时间
            start_time = time.perf_counter()
            # 发送GET请求
            response = session.get(
                url=TARGET_URL,
                timeout=TIMEOUT
            )
            # 记录请求结束时间
            end_time = time.perf_counter()
            response_time = (end_time - start_time) * 1000  # 转换为毫秒

            # 验证请求是否成功（响应状态码200）
            if response.status_code == 200:
                with lock:  # 加锁修改全局变量，避免线程冲突
                    total_success += 1
                    response_times.append(response_time)
                print(f"[线程{thread_id}] 请求{req_id} 成功 | 响应时间：{response_time:.2f}ms | 响应状态码：{response.status_code}")
            else:
                with lock:
                    total_failure += 1
                print(f"[线程{thread_id}] 请求{req_id} 失败 | 响应状态码：{response.status_code}")

            print(total_success)
        except Exception as e:
            with lock:
                total_failure += 1
            print(f"[线程{thread_id}] 请求{req_id} 异常 | 错误信息：{str(e)}")
  • 核心说明：
    1. requests.Session()：每个线程创建一个Session对象，复用TCP连接（避免每次请求都创建新连接），大幅提升压测效率
    2. time.perf_counter()：高精度时间统计函数，用于计算请求响应时间（转换为毫秒后，精度更高，便于分析接口性能）
    3. 异常处理：捕获请求超时、网络中断、接口报错等异常，统一计入total_failure
    4. with lock：上下文管理器自动加锁/释放锁，修改全局变量时保证线程安全，避免数据统计偏差
    5. 实时打印：输出单个请求的执行结果（成功/失败/异常），便于实时监控压测过程中的接口状态
3.4 压测主函数 run_benchmark
def run_benchmark() -> None:
    """
    启动压测：创建并启动所有线程，等待所有线程执行完成，输出统计结果
    """
    start_time = datetime.now()
    print("=" * 80)
    print(f"压测开始时间：{start_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"目标接口：{TARGET_URL}")
    print(f"并发线程数：{CONCURRENT_THREADS}")
    print(f"每个线程请求数：{TOTAL_REQUESTS_PER_THREAD}")
    print(f"总请求数：{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print("=" * 80 + "\n")

    # 创建线程列表
    threads: List[threading.Thread] = []
    for thread_id in range(1, CONCURRENT_THREADS + 1):
        thread = threading.Thread(
            target=send_requests,
            args=(thread_id,),
            name=f"Benchmark-Thread-{thread_id}"
        )
        threads.append(thread)
        thread.start()  # 启动线程

    # 等待所有线程执行完成
    for thread in threads:
        thread.join()

    # 计算统计结果
    end_time = datetime.now()
    total_duration = (end_time - start_time).total_seconds()
    avg_response_time = sum(response_times) / len(response_times) if response_times else 0
    qps = total_success / total_duration if total_duration > 0 else 0  # 每秒查询率（仅统计成功请求）

    # 输出最终统计结果
    print("\n" + "=" * 80)
    print(f"压测结束时间：{end_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"总耗时：{total_duration:.2f} 秒")
    print(f"总请求数：{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print(f"成功请求数：{total_success}")
    print(f"失败请求数：{total_failure}")
    print(f"成功率：{(total_success / (total_success + total_failure) * 100):.2f}%" if (total_success + total_failure) > 0 else "成功率：0%")
    print(f"平均响应时间：{avg_response_time:.2f} ms")
    print(f"QPS（每秒查询率）：{qps:.2f}")
    print("=" * 80)
  • 核心说明：
    1. 压测前信息打印：输出压测配置参数，便于确认压测场景是否符合预期
    2. 线程创建与启动：
      • 循环创建指定数量的线程，每个线程绑定send_requests函数，并传入线程ID
      • thread.start()启动线程，所有线程同时开始执行请求发送逻辑
    3. thread.join()：等待所有线程执行完成后，再进行统计结果计算，确保统计数据完整
    4. 核心指标计算：
      • total_duration：压测总耗时（从第一个线程启动到最后一个线程结束）
      • avg_response_time：成功请求的平均响应时间（仅统计成功请求，更能反映接口正常性能）
      • qps：每秒查询率（成功请求数/总耗时），衡量接口的并发处理能力
    5. 压测后汇总输出：以清晰格式输出核心统计指标，便于分析接口性能瓶颈
3.5 程序入口
if __name__ == "__main__":
    run_benchmark()
  • 核心说明：程序运行时，自动调用run_benchmark函数，启动完整压测流程

4. 使用指南

4.1 前置准备
  1. 安装依赖：pip install requests
  2. 确保FastAPI用户管理接口服务已正常启动（http://localhost:8000/api/shop/users可正常访问并返回数据）
  3. 根据实际测试需求，修改压测配置项（如调整并发线程数、单线程请求数）
4.2 启动压测
  1. 将代码保存为api_benchmark.py
  2. 运行命令：python api_benchmark.py
  3. 压测启动标志：控制台输出压测配置信息，随后开始实时打印单个请求的执行结果
4.3 压测结果解读
指标名称指标含义解读要点
总耗时整个压测流程的持续时间反映完成所有请求所需的时间，结合总请求数可初步判断接口处理效率
成功请求数/失败请求数压测过程中成功/失败的请求总量失败请求数>0时，需排查接口是否存在性能瓶颈或稳定性问题
成功率成功请求数占总请求数的比例理想状态下成功率应为100%，若低于99%，需重点分析失败原因
平均响应时间所有成功请求的响应时间平均值反映接口的平均处理速度，数值越低，接口性能越好
QPS（每秒查询率）每秒能处理的成功请求数衡量接口并发处理能力的核心指标，数值越高，接口的高并发支撑能力越强

5. 优化建议与注意事项

5.1 压测配置优化建议
  1. 逐步提升并发量：从低并发（如5线程）开始，逐步增加到高并发（如50、100线程），避免一次性高并发压垮服务器
  2. 控制单线程请求数：单线程请求数建议设置为50-200，过多可能导致单个线程运行时间过长，影响压测效率
  3. 合理设置超时时间：根据接口正常响应时间调整TIMEOUT（如接口正常响应时间<1秒，可设置为5秒），避免超时时间过长导致压测结果失真
5.2 线程安全注意事项
  1. 全局变量修改必须加锁：total_success、total_failure、response_times为全局变量，多线程修改时必须通过with lock保证线程安全，否则会出现统计数据错误
  2. 每个线程独立创建requests.Session：避免多个线程共享一个Session对象，导致请求冲突或连接泄露
5.3 压测环境注意事项
  1. 压测环境与生产环境尽量一致：确保硬件配置、MySQL配置、服务部署方式与生产环境一致，压测结果才具有参考价值
  2. 避免在生产环境直接压测：压测会占用大量服务器资源，可能影响生产业务正常运行，建议在测试环境进行压测
  3. 压测前备份数据库：高并发压测可能导致数据库负载过高，甚至出现数据异常，压测前建议备份shop数据库
5.4 功能扩展建议
  1. 支持POST接口压测：添加请求体配置项，修改session.get为session.post，支持对插入接口进行压测
  2. 增加响应数据校验：校验接口返回数据的格式和内容，避免接口返回200但数据异常的情况
  3. 生成压测报告：将压测结果保存为CSV/HTML文件，便于后续分析和归档
  4. 支持自定义请求头：添加请求头配置项，支持携带认证信息、Content-Type等自定义请求头

第三部分：两份代码的联动说明与整体总结

1. 联动流程

  1. 启动FastAPI用户管理接口服务，确保GET /api/shop/users接口可正常访问
  2. 配置压测工具的TARGET_URL与FastAPI接口地址一致
  3. 启动压测工具，模拟多线程并发请求，对接口进行性能测试
  4. 查看压测结果，分析接口成功率、响应时间、QPS等指标
  5. 根据压测结果优化FastAPI服务（如调整连接池配置、优化SQL、开启多进程运行）

2. 整体总结

  1. 两份代码实现了「后端服务搭建」与「接口性能压测」的完整闭环，便于快速验证用户管理接口的功能和性能
  2. FastAPI接口服务具备高可用性、安全性、可扩展性，支持后续功能扩展（如用户更新、删除、分页查询）
  3. 多线程压测工具轻量易用、配置灵活，可快速适配不同接口的压测需求，为接口性能优化提供数据支撑
  4. 核心亮点：
    • 后端服务：连接池复用、参数校验、事务保障、防SQL注入，确保服务稳定安全
    • 压测工具：线程安全、实时监控、核心指标统计，确保压测结果准确可靠
  5. 后续优化方向：
    • 后端：采用异步数据库驱动（asyncmy），提升接口并发处理能力；添加日志模块，便于问题排查
    • 压测工具：支持分布式压测、自定义压测场景，提升压测的覆盖度和专业性
AI模型部署工具选型终极指南：vLLM vs TGI vs FastAPI，2025最新对比（附压测数据）
AI开发架构师
09-01 919
想象你是一位厨师，经过数月研发出一道绝世美味的菜肴（训练出一个高性能AI模型）。然而，当你准备将这道菜推向市场时，却发现厨房设备（部署工具）无法满足大规模供应需求——要么出菜速度太慢，要么品质不稳定，要么成本高昂得令人却步。模型性能的提升速度远超部署技术的发展。根据Gartner 2025年报告，78%的AI项目在模型训练完成后卡在了部署阶段，无法有效转化为业务价值。这一现象被称为"AI价值鸿沟"，而部署工具正是跨越这道鸿沟的关键桥梁。图1：AI项目生命周期中各阶段的时间占比，部署阶段往往成为瓶颈。
QLoRA 精调模型如何部署上线？FastAPI 封装 × Docker 打包 × 多模型热切换实战指南
努力分享一些人工智能、计算机视觉、影像等相关的知识干货！
04-02 2214
很多人做到这一步已经训练出了一个挺不错的国产大模型微调版本，但随之而来的问题是：“我怎么把它做成一个 API？“怎么上线一套本地服务供团队调用？“要不要上 vLLM？用 Docker 好不好？我们先快速了解几种常见的部署方式，然后再进入实战。
性能比拼: Go标准库 vs Python FastAPI
techdashen的博客
03-31 1316
这轮测试没有任何依赖项，甚至没有业务逻辑，仅仅是返回硬编码的数据给客户端。，因为它的性能更高。但如果你感兴趣，可以在另外的视频中看到它与。部署这些应用程序，因此测试环境尽可能贴近真实生产环境。由于测试不需要太多内存，所以我尽可能优化成本。等其他基准测试感兴趣，可以查看我的频道。Go最后的延迟峰值是由于文件描述符造成的。计算优化实例的硬件与通用实例相同，但。监测每个应用的关键操作，例如。如果你有优化方案，欢迎提交。，本来期望它的性能会更好。如果你有优化方案，欢迎查看。在本视频中，我们将对比。
fastapi 如何控制并发——其三
骑者，且赶路
07-26 3037
随后我们改用多进程的方式去测试，在客户端并发数为4，服务端进程数为8的情况下，平均耗时也有347ms，并且成功率只有22%，这里的347s存在水分，很多失败的请求只有1～2ms，存在摊还的情况。那可能真的是在并发数上来的情况下确实是耗时增大了，我们猜测是并发多了后，CPU成为了瓶颈，我们在使用多进程方案时，观察CPU利用率，发现确实已经占满了。上面我们使用的是多线程编程，正如我们之前所说的，对于计算密集型服务，python的多进程就是个笑话，这是由于。因此我们有必要测试在多核机器上，多线程方案的表现。
Awesome FastAPI性能测试：Locust与wrk压测实战
gitblog_00065的博客
10-18 572
你是否遇到过API上线后响应变慢的问题？是否想知道自己的FastAPI应用能承受多少并发用户？本文将通过实战案例，教你使用Locust和wrk两款工具对FastAPI应用进行性能测试，帮助你准确评估系统瓶颈，优化应用性能。读完本文，你将掌握性能测试环境搭建、测试脚本编写、测试结果分析的完整流程，让你的API在高并发场景下依然稳定可靠。 ## FastAPI性能测试概述 FastAPI作为一款现...
Django 和 FastAPI 的区别：全面对比与选择指南
欢迎来到运通链达的官方博客！我们深度探讨人工智能技术与应用，贯彻科技向善理念，推动科技进步与社会福祉和谐共生。
05-04 2592
在Python生态中，Django与FastAPI代表了两种截然不同的开发哲学：全栈框架的厚重与API优先的敏捷。本文从性能、生态、安全等八大维度深度剖析两者差异，结合2023年开发者调查报告、企业案例及性能基准测试数据，为技术选型提供全景视角。
极限并发调试现场：用`asyncio`优化FastAPI响应时间
itAred的博客
05-15 1011
在一次线上会议中，团队面临FastAPI应用在高并发场景下响应时间飙升的问题。面试官要求候选人现场分析并优化，候选人通过深入理解`asyncio`事件循环机制，结合`uvloop`替换默认事件循环，成功将响应时间从500ms优化至20ms。
Python异步框架深度对比（Sanic vs FastAPI性能压测大揭秘）
VarLens的博客
11-05 1012
解决高并发Web开发选型难题，本文深入剖析Python异步Web框架Sanic vs FastAPI性能差异，涵盖基准压测、路由设计、类型提示与部署优化。对比适用场景与开发效率，助你精准选择技术栈，值得收藏。
FastAPI 高性能 API 开发：依赖注入与异步请求的企业级实践
2501_93894370的博客
10-30 421
（Starlette + Uvicorn），支持原生异步请求处理。：在高并发场景下，结合 Redis 缓存依赖计算结果，避免重复执行复杂初始化逻辑。FastAPI 基于。
深入理解 Uvicorn Workers：FastAPI 与 ASGI 应用的并发利器
gs80140的专栏
05-30 1722
摘要：Uvicorn Workers是提升FastAPI等ASGI应用性能的关键配置，通过Gunicorn多进程模型结合Uvicorn的异步能力实现高并发。单Worker受限于Python GIL，推荐采用2*CPU+1的多Worker模式（如4核用9 Workers），可显著提升QPS和稳定性。部署命令示例：gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app。注意多Worker需配合共享存储，开发时禁用reload，生产环境建议搭配Nginx使用
FastAPI 高级特性：同异步路由函数、依赖注入与后台任务
qq_43629857的博客
02-24 129
在现代 Web 开发中，高效的性能和简洁的代码结构是至关重要的。FastAPI 作为一个现代、快速（高性能）的 Web 框架，凭借其对异步编程的原生支持和直观的依赖注入系统，迅速成为开发者的热门选择。在本文中，将深入探讨 `FastAPI` 中的几个核心概念：同异步函数的区别、`Depends` 依赖以及后台任务。
使用python操作MySQL
2201_75573294的博客
12-25 1247
连接池是创建和管理一个连接的缓冲池的技术，这些连接准备好被任何需要它们的线程使用。连接池用于提高在数据库上执行命令的性能。连接池本质上就是数据库连接的缓存。使用数据库连接时，如果池中有一个可用，它将使用该连接而不是重新建立另一个新的连接 ，用完后不是关闭它，而是将其放回池中。2：druid功能最为全面，sql拦截等功能，统计数据较为全面，具有良好的扩展性。3：综合性能，扩展性等方面，可考虑使用druid或者hikariCP连接池。5.HikariCP连接池的使用。3.常见的数据连接池。
CentOS 8 完整实现 Rsyslog 日志写入 MySQL 数据库
weixin_40107423的博客
12-30 38
1.校验 Rsyslog 配置语法（最常用）
优化SQL：如何使用 EXPLAIN
qq_45873770的博客
12-26 842
EXPLAIN是优化SQL查询不可或缺的工具。掌握其输出结果中type和Extra列的含义，是定位性能问题的关键。ALLrefrangeExtra下面这个表格汇总了使用EXPLAIN时返回结果中各字段的核心含义。字段含义与解读要点id​SELECT 查询的序列号。。​查询的类型，例如简单查询（SIMPLE）、主查询（PRIMARY）、子查询（SUBQUERY）、派生表查询（DERIVED）等。type​，即MySQL决定如何查找表中的行。
【网络运维】MySQL 高可用架构实践：备份策略、主从复制与读写分离
G_H_S_3_的博客
12-26 760
本文讲解并示例了MySQL的备份策略，并对MySQL主从复制部署和读写分离进行了部署实践。
MySQL服务无法启动问题
m0_53665440的博客
12-29 110
输入mysqld --console查看错误详情这说明。你的电脑上其实已经有一个 MySQL 进程在后台运行了，所以当你尝试再启动一个新服务时，它会因为抢不到端口而导致“服务无法启动”。
Android模拟器ADB异常断开一个容易忽视原因的记录
最新发布
fanqi987的专栏
12-30 161
Google Play镜像，功能齐全，内部具有了除了Google地图和基础等登录API外，也有消费者功能，就是Google Play商店应用。无论是运行还是调试过程，ADB都会频繁重启，查看端口链接似乎也会有多个ADB的建立，后期考虑是ADB多次重启，端口连接建立冲突导致。具体出错原因就是，Android模拟器Play镜像使用时会有连接稳定性差的现象，并不适合开发流程时使用。这是官方对两种镜像的介绍，以前我基本是混用两者，或者主要使用Play镜像。不出问题的话，混用倒无所谓，出问题了就很难发现原因。
【Android】第1篇：ADB的使用教程
黑猫奥利奥的博客
12-28 48
教会你实用adb
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值