Rust中的Context与任务上下文传递：深入理解与实践

2301_80320999

1007人浏览 · 2025-10-30 22:13:40

2301_80320999 · 2025-10-30 22:13:40 发布

在这里插入图片描述

引言：异步编程中的上下文挑战

在现代应用开发中，尤其是在异步编程模型下，上下文传递是一个核心挑战。无论是日志记录、追踪、认证信息还是配置参数，都需要在复杂的异步调用链中有效传递。Rust作为一门注重性能和安全的系统级编程语言，提供了独特的Context机制来解决这个问题。本文将深入探讨Rust中Context的设计原理、实现机制以及在实际项目中的最佳实践。

一、Rust中的Context基础

1.1 Context的定义与作用

在Rust的异步编程模型中，Context结构体扮演着至关重要的角色。它定义在std::task::Context中，主要用于在Future的poll方法中传递唤醒器（Waker）和其他任务相关的上下文信息。

pub struct Context<'a> {
    waker: &'a Waker,
    // 私有字段，用于扩展
}

Context的主要作用：

提供waker用于唤醒任务
支持任务的取消和优先级管理
作为扩展点，支持自定义上下文信息

1.2 Waker与任务唤醒机制

Waker是Context中最核心的组件，它允许异步运行时在事件就绪时唤醒等待中的任务：

use std::task::{Context, Poll, Waker};
use std::pin::Pin;
use std::future::Future;

struct MyFuture;

impl Future for MyFuture {
    type Output = ();
    
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // 检查是否有事件就绪
        if event_is_ready() {
            Poll::Ready(())
        } else {
            // 注册waker，以便事件就绪时唤醒
            register_waker(cx.waker().clone());
            Poll::Pending
        }
    }
}

1.3 Context的生命周期

Context的生命周期参数'a确保了它不会超过其引用的waker的生命周期，这是Rust内存安全保证的重要体现：

fn process_context<'a>(cx: &mut Context<'a>) {
    // cx的生命周期被限制在'a内
    let waker = cx.waker();
    // 使用waker...
}

二、深入理解Context的实现机制

2.1 Context的内存布局

Context结构体的内存布局经过精心设计，以确保高效访问：

// Context的实际内存布局（简化版）
struct Context<'a> {
    waker: &'a Waker,
    data: *const (), // 指向自定义数据的指针
}

// Waker的内部结构
struct Waker {
    vtable: &'static WakerVTable,
    data: *const (),
}

struct WakerVTable {
    wake: unsafe fn(*const ()),
    wake_by_ref: unsafe fn(*const ()),
    drop: unsafe fn(*const ()),
}

2.2 Context与Future的交互

Context通过poll方法与Future进行交互，形成了异步编程的核心循环：

// 简化的异步运行时循环
fn run_executor() {
    let mut task = Some(Box::pin(my_async_function()));
    let waker = create_waker();
    let mut cx = Context::from_waker(&waker);
    
    while let Some(mut future) = task.take() {
        match Pin::new(&mut future).poll(&mut cx) {
            Poll::Ready(result) => {
                // 处理结果
                println!("Task completed with result: {:?}", result);
            }
            Poll::Pending => {
                // 任务未完成，放回任务队列
                task = Some(future);
                
                // 等待事件通知
                wait_for_events();
            }
        }
    }
}

2.3 Context的扩展机制

虽然标准库中的Context主要用于传递Waker，但Rust的类型系统允许我们通过组合来扩展Context的功能：

use std::task::Context;

// 扩展Context以支持日志记录
struct LoggingContext<'a> {
    inner: &'a mut Context<'a>,
    request_id: String,
    logger: Logger,
}

impl<'a> LoggingContext<'a> {
    fn new(inner: &'a mut Context<'a>, request_id: String, logger: Logger) -> Self {
        LoggingContext {
            inner,
            request_id,
            logger,
        }
    }
    
    fn log(&self, message: &str) {
        self.logger.log(&format!("[{}] {}", self.request_id, message));
    }
    
    // 委托给内部Context的方法
    fn waker(&self) -> &'a std::task::Waker {
        self.inner.waker()
    }
}

三、任务上下文传递的模式与实践

3.1 显式参数传递

最直接的上下文传递方式是通过函数参数显式传递：

use std::task::Context;

// 配置上下文
struct AppContext {
    config: Config,
    logger: Logger,
    metrics: MetricsCollector,
}

// 数据库服务
struct DatabaseService {
    connection_pool: ConnectionPool,
}

impl DatabaseService {
    async fn query(
        &self,
        ctx: &AppContext,
        sql: &str,
    ) -> Result<Vec<Row>, DatabaseError> {
        ctx.logger.debug(&format!("Executing SQL: {}", sql));
        
        let start_time = std::time::Instant::now();
        
        let result = self.connection_pool.query(sql).await;
        
        ctx.metrics.record_query_duration(
            "database.query",
            start_time.elapsed()
        );
        
        result
    }
}

// HTTP处理函数
async fn handle_request(
    ctx: &AppContext,
    req: Request<Body>,
    db: &DatabaseService,
) -> Response<Body> {
    let user_id = get_user_id_from_request(&req);
    
    match db.query(ctx, &format!("SELECT * FROM users WHERE id = {}", user_id)).await {
        Ok(rows) => Response::new(Body::from(rows_to_json(&rows))),
        Err(e) => {
            ctx.logger.error(&format!("Database error: {}", e));
            Response::builder()
                .status(StatusCode::INTERNAL_SERVER_ERROR)
                .body(Body::from("Internal server error"))
                .unwrap()
        }
    }
}

3.2 使用AsyncLocal存储

对于复杂的异步调用链，显式传递上下文会变得繁琐。tokio::task::LocalSet和async_local crate提供了更好的解决方案：

use async_local::AsyncLocal;
use tokio::runtime::Runtime;

// 定义异步本地存储
static APP_CONTEXT: AsyncLocal<AppContext> = AsyncLocal::new();

// 初始化上下文并运行异步任务
fn run_with_context<F, R>(ctx: AppContext, f: F) -> R
where
    F: FnOnce() -> R + 'static,
    R: 'static,
{
    APP_CONTEXT.scope(ctx, f)
}

// 在异步函数中访问上下文
async fn database_query(sql: &str) -> Result<Vec<Row>, DatabaseError> {
    // 从AsyncLocal中获取上下文
    let ctx = APP_CONTEXT.get().unwrap();
    
    ctx.logger.debug(&format!("Executing SQL: {}", sql));
    
    let start_time = std::time::Instant::now();
    
    let result = ConnectionPool::get().query(sql).await;
    
    ctx.metrics.record_query_duration(
        "database.query",
        start_time.elapsed()
    );
    
    result
}

// HTTP处理函数
async fn handle_request(req: Request<Body>) -> Response<Body> {
    // 从请求中提取上下文信息
    let request_id = extract_request_id(&req);
    let user_id = get_user_id_from_request(&req);
    
    // 创建请求特定的上下文
    let ctx = AppContext {
        config: Config::get(),
        logger: Logger::with_request_id(request_id.clone()),
        metrics: MetricsCollector::new(),
        request_id,
        user_id,
    };
    
    // 在上下文中运行异步操作
    run_with_context(ctx, async move {
        match database_query(&format!("SELECT * FROM users WHERE id = {}", user_id)).await {
            Ok(rows) => Response::new(Body::from(rows_to_json(&rows))),
            Err(e) => {
                // 可以直接访问上下文，因为我们在scope中
                let ctx = APP_CONTEXT.get().unwrap();
                ctx.logger.error(&format!("Database error: {}", e));
                
                Response::builder()
                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                    .body(Body::from("Internal server error"))
                    .unwrap()
            }
        }
    }).await
}

3.3 自定义Future实现上下文传递

通过自定义Future，我们可以在异步调用链中自动传递上下文：

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// 带上下文的Future
struct FutureWithContext<F, C> {
    future: F,
    context: C,
}

impl<F, C> FutureWithContext<F, C> {
    fn new(future: F, context: C) -> Self {
        FutureWithContext { future, context }
    }
}

impl<F: Future, C> Future for FutureWithContext<F, C> {
    type Output = (F::Output, C);
    
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let future = Pin::new(&mut self.future);
        
        match future.poll(cx) {
            Poll::Ready(output) => {
                Poll::Ready((output, std::mem::take(&mut self.context)))
            }
            Poll::Pending => Poll::Pending,
        }
    }
}

// 使用示例
async fn process_data(data: Vec<u8>, context: AppContext) -> Result<(), Error> {
    // 处理数据的异步操作
    let result = validate_data(&data).await?;
    let result = transform_data(result).await?;
    save_data(result).await
}

// 带上下文的处理链
async fn data_pipeline(data: Vec<u8>, initial_context: AppContext) -> Result<AppContext, Error> {
    let (result, context) = FutureWithContext::new(process_data(data, initial_context), initial_context).await;
    
    // 记录处理结果
    context.logger.info(&format!("Data processing completed: {:?}", result));
    
    Ok(context)
}

四、深度实践：构建可观测的异步服务

让我们通过一个完整的示例来展示如何在实际项目中有效使用Context进行任务上下文传递：

use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
use tokio::sync::RwLock;
use hyper::{Body, Request, Response, Server, StatusCode};
use hyper::service::{make_service_fn, service_fn};
use tracing::{info, error, debug, span, Level};
use tracing_futures::Instrument;

// 应用配置
#[derive(Clone)]
struct Config {
    database_url: String,
    server_port: u16,
    log_level: String,
}

// 请求上下文
#[derive(Clone)]
struct RequestContext {
    request_id: String,
    trace_id: String,
    user_id: Option<String>,
    start_time: Instant,
    metrics: Arc<MetricsCollector>,
    logger: Logger,
}

impl RequestContext {
    fn new(request_id: String, metrics: Arc<MetricsCollector>) -> Self {
        RequestContext {
            request_id: request_id.clone(),
            trace_id: format!("trace-{}", uuid::Uuid::new_v4()),
            user_id: None,
            start_time: Instant::now(),
            metrics: metrics.clone(),
            logger: Logger::new(request_id, metrics),
        }
    }
    
    fn record_response(&self, status_code: StatusCode) {
        let duration = self.start_time.elapsed();
        self.metrics.record_request_duration(
            "http.request",
            duration,
            status_code.as_u16().to_string()
        );
    }
}

// 数据库服务
struct DatabaseService {
    connection_pool: Arc<sqlx::PgPool>,
}

impl DatabaseService {
    async fn new(config: &Config) -> Self {
        let pool = sqlx::PgPool::connect(&config.database_url).await.unwrap();
        DatabaseService {
            connection_pool: Arc::new(pool),
        }
    }
    
    async fn get_user(&self, ctx: &RequestContext, user_id: &str) -> Result<User, sqlx::Error> {
        let span = span!(Level::INFO, "database.get_user", user_id = user_id);
        let _enter = span.enter();
        
        debug!("Fetching user from database");
        
        let user = sqlx::query_as!(User, "SELECT id, name, email FROM users WHERE id = $1", user_id)
            .fetch_one(&*self.connection_pool)
            .await;
        
        match &user {
            Ok(_) => info!("User fetched successfully"),
            Err(e) => error!("Failed to fetch user: {}", e),
        }
        
        user
    }
}

// 用户结构体
#[derive(Debug, Clone)]
struct User {
    id: String,
    name: String,
    email: String,
}

// 指标收集器
struct MetricsCollector {
    request_counts: RwLock<HashMap<String, u64>>,
    request_durations: RwLock<HashMap<String, Vec<std::time::Duration>>>,
}

impl MetricsCollector {
    fn new() -> Arc<Self> {
        Arc::new(MetricsCollector {
            request_counts: RwLock::new(HashMap::new()),
            request_durations: RwLock::new(HashMap::new()),
        })
    }
    
    async fn record_request_duration(&self, endpoint: &str, duration: std::time::Duration, status: String) {
        let key = format!("{}.{}", endpoint, status);
        let mut durations = self.request_durations.write().await;
        durations.entry(key).or_insert_with(Vec::new).push(duration);
        
        let mut counts = self.request_counts.write().await;
        *counts.entry(key).or_insert(0) += 1;
    }
    
    async fn get_metrics(&self) -> String {
        let counts = self.request_counts.read().await;
        let durations = self.request_durations.read().await;
        
        let mut metrics = String::new();
        
        for (key, count) in counts.iter() {
            metrics.push_str(&format!("request_count{{endpoint=\"{}\"}} {}\n", key, count));
        }
        
        for (key, duration_list) in durations.iter() {
            if !duration_list.is_empty() {
                let avg_duration = duration_list.iter().sum::<std::time::Duration>() / duration_list.len() as u32;
                metrics.push_str(&format!("request_duration_seconds{{endpoint=\"{}\"}} {}\n", 
                    key, avg_duration.as_secs_f64()));
            }
        }
        
        metrics
    }
}

// 日志记录器
struct Logger {
    request_id: String,
    metrics: Arc<MetricsCollector>,
}

impl Logger {
    fn new(request_id: String, metrics: Arc<MetricsCollector>) -> Self {
        Logger {
            request_id,
            metrics,
        }
    }
    
    fn info(&self, message: &str) {
        println!("[INFO] [{}] {}", self.request_id, message);
    }
    
    fn error(&self, message: &str) {
        println!("[ERROR] [{}] {}", self.request_id, message);
    }
    
    fn debug(&self, message: &str) {
        println!("[DEBUG] [{}] {}", self.request_id, message);
    }
}

// 请求处理函数
async fn handle_request(
    req: Request<Body>,
    db_service: Arc<DatabaseService>,
    metrics: Arc<MetricsCollector>,
) -> Result<Response<Body>, hyper::Error> {
    // 从请求头中提取或生成request_id
    let request_id = req.headers()
        .get("X-Request-ID")
        .and_then(|h| h.to_str().ok())
        .unwrap_or(&format!("req-{}", uuid::Uuid::new_v4()))
        .to_string();
    
    // 创建请求上下文
    let ctx = RequestContext::new(request_id, metrics.clone());
    
    // 创建tracing span
    let span = span!(Level::INFO, "http.request", request_id = %ctx.request_id);
    
    // 使用instrument将span与异步任务关联
    async move {
        ctx.logger.info(&format!("Received request: {} {}", req.method(), req.uri()));
        
        // 路由处理
        let response = match (req.method(), req.uri().path()) {
            (&hyper::Method::GET, "/users/:user_id") => {
                let user_id = req.uri().path().split('/').last().unwrap_or("");
                
                match db_service.get_user(&ctx, user_id).await {
                    Ok(user) => Response::new(Body::from(format!(
                        "User: {} - {} ({})", user.id, user.name, user.email
                    ))),
                    Err(e) => Response::builder()
                        .status(StatusCode::NOT_FOUND)
                        .body(Body::from(format!("User not found: {}", e)))
                        .unwrap(),
                }
            }
            
            (&hyper::Method::GET, "/metrics") => {
                let metrics_data = metrics.get_metrics().await;
                Response::new(Body::from(metrics_data))
            }
            
            _ => Response::builder()
                .status(StatusCode::NOT_FOUND)
                .body(Body::from("Not found"))
                .unwrap(),
        };
        
        // 记录响应状态和持续时间
        ctx.record_response(response.status());
        
        Ok(response)
    }.instrument(span).await
}

#[tokio::main]
async fn main() {
    // 初始化配置
    let config = Config {
        database_url: "postgres://user:password@localhost:5432/mydb".to_string(),
        server_port: 3000,
        log_level: "info".to_string(),
    };
    
    // 初始化指标收集器
    let metrics = MetricsCollector::new();
    
    // 初始化数据库服务
    let db_service = Arc::new(DatabaseService::new(&config).await);
    
    // 绑定地址
    let addr = ([127, 0, 0, 1], config.server_port).into();
    
    // 创建服务
    let make_svc = make_service_fn(move |_conn| {
        let db_service = db_service.clone();
        let metrics = metrics.clone();
        
        async move {
            Ok::<_, hyper::Error>(service_fn(move |req| {
                handle_request(req, db_service.clone(), metrics.clone())
            }))
        }
    });
    
    // 启动服务器
    let server = Server::bind(&addr).serve(make_svc);
    
    println!("Server running on http://{}", addr);
    
    // 运行服务器直到停止
    if let Err(e) = server.await {
        eprintln!("Server error: {}", e);
    }
}

代码分析与最佳实践

请求上下文设计：RequestContext结构体包含了处理请求所需的所有信息，包括请求ID、追踪ID、用户ID、开始时间、指标收集器和日志记录器。
上下文传递模式：
- 使用Arc实现上下文的高效共享
- 通过函数参数显式传递上下文
- 使用tracing库的instrument宏实现追踪上下文的自动传递
可观测性实现：
- 每个请求都有唯一的请求ID，便于日志关联
- 使用Instant记录请求处理时间
- 指标收集器记录请求计数和持续时间
- 支持/metrics端点暴露Prometheus格式的指标
异步安全：
- 使用RwLock实现指标数据的线程安全访问
- 通过Arc实现共享状态的高效传递
- 所有异步操作都正确处理了取消和错误

五、高级话题：Context与异步运行时

5.1 Context与Tokio运行时

Tokio运行时对Context有特殊的优化和扩展：

use tokio::runtime::Runtime;
use tokio::task::{self, LocalSet};

fn main() {
    // 创建自定义Tokio运行时
    let rt = Runtime::new().unwrap();
    
    // 在运行时中执行异步任务
    rt.block_on(async {
        // 创建本地任务集
        let local = LocalSet::new();
        
        // 在本地任务集中运行任务
        local.run_until(async {
            // 创建带上下文的任务
            let task = task::spawn_local(async {
                // 任务逻辑
                println!("Task running");
            });
            
            task.await.unwrap();
        }).await;
    });
}

5.2 Context与任务取消

Context机制在任务取消中扮演着重要角色：

use std::time::Duration;
use tokio::time;
use tokio::task::{self, JoinHandle};

async fn long_running_task(ctx: AppContext) -> Result<(), Box<dyn std::error::Error>> {
    ctx.logger.info("Starting long running task");
    
    // 模拟长时间运行的操作
    for i in 0..10 {
        // 检查任务是否被取消
        if task::is_current_task_cancelled() {
            ctx.logger.info("Task was cancelled");
            return Err("Task cancelled".into());
        }
        
        ctx.logger.debug(&format!("Working... {}/10", i + 1));
        time::sleep(Duration::from_secs(1)).await;
    }
    
    ctx.logger.info("Task completed successfully");
    Ok(())
}

async fn run_with_timeout(ctx: AppContext) -> Result<(), Box<dyn std::error::Error>> {
    let task = task::spawn(async move {
        long_running_task(ctx.clone()).await
    });
    
    // 设置5秒超时
    match time::timeout(Duration::from_secs(5), task).await {
        Ok(result) => result?,
        Err(_) => {
            ctx.logger.error("Task timed out");
            return Err("Task timed out".into());
        }
    }
    
    Ok(())
}

5.3 Context与异步信号处理

Context可以与信号处理结合，实现优雅的关闭：

use tokio::signal;
use tokio::sync::broadcast;
use tokio::sync::broadcast::Sender;

// 应用关闭信号
struct ShutdownSignal {
    tx: Sender<()>,
}

impl ShutdownSignal {
    fn new() -> Self {
        let (tx, _) = broadcast::channel(1);
        ShutdownSignal { tx }
    }
    
    fn trigger(&self) {
        let _ = self.tx.send(());
    }
    
    async fn wait(&self) {
        let mut rx = self.tx.subscribe();
        let _ = rx.recv().await;
    }
}

async fn start_signal_handler(shutdown: ShutdownSignal) {
    // 监听SIGINT和SIGTERM信号
    let mut sigint = signal::unix::signal(signal::unix::SignalKind::interrupt()).unwrap();
    let mut sigterm = signal::unix::signal(signal::unix::SignalKind::terminate()).unwrap();
    
    tokio::select! {
        _ = sigint.recv() => shutdown.trigger(),
        _ = sigterm.recv() => shutdown.trigger(),
    }
}

async fn background_worker(ctx: AppContext, shutdown: ShutdownSignal) {
    ctx.logger.info("Background worker started");
    
    loop {
        tokio::select! {
            // 定期执行任务
            _ = tokio::time::sleep(Duration::from_secs(10)) => {
                ctx.logger.info("Performing background task");
                // 执行后台任务
            }
            
            // 等待关闭信号
            _ = shutdown.wait() => {
                ctx.logger.info("Background worker shutting down");
                break;
            }
        }
    }
}

六、Context传递的性能考量

6.1 避免过度使用Arc

虽然Arc是共享上下文的常用方式，但过度使用会增加内存开销和原子操作：

// 不推荐：每个字段都使用Arc
struct BadContext {
    config: Arc<Config>,
    logger: Arc<Logger>,
    metrics: Arc<MetricsCollector>,
}

// 推荐：整体使用Arc包装
struct GoodContext {
    config: Config,
    logger: Logger,
    metrics: MetricsCollector,
}

// 使用时整体包装
type SharedContext = Arc<GoodContext>;

6.2 Context的克隆成本

在设计Context结构体时，应考虑克隆成本：

// 不推荐：包含大量数据的Context
struct HeavyContext {
    request_id: String,
    large_data: Vec<u8>, // 大量数据
    logger: Logger,
}

// 推荐：分离不变数据和可变数据
struct LightContext {
    request_id: String,
    shared_data: Arc<SharedData>, // 共享的不变数据
    logger: Logger,
}

struct SharedData {
    config: Config,
    // 其他不变数据
}

6.3 上下文的生命周期管理

合理管理上下文的生命周期可以避免内存泄漏：

async fn process_with_context(ctx: RequestContext) -> Result<(), Error> {
    // 使用Guard模式确保资源正确释放
    let _guard = ContextGuard::new(&ctx);
    
    // 处理逻辑
    Ok(())
}

struct ContextGuard<'a> {
    ctx: &'a RequestContext,
}

impl<'a> ContextGuard<'a> {
    fn new(ctx: &'a RequestContext) -> Self {
        ContextGuard { ctx }
    }
}

impl<'a> Drop for ContextGuard<'a> {
    fn drop(&mut self) {
        // 在上下文生命周期结束时执行清理操作
        self.ctx.logger.info("Context guard dropped");
    }
}

七、总结与最佳实践

7.1 Context设计原则

最小化原则：只包含必要的信息，避免上下文过大
不可变性：尽量使上下文不可变，减少并发问题
层次化：设计层次化的上下文结构，便于扩展
类型安全：利用Rust的类型系统确保上下文使用的安全性

7.2 上下文传递模式选择

传递模式	优点	缺点	适用场景
显式参数	简单直接，类型安全	调用链长时繁琐	简单应用，短调用链
AsyncLocal	透明传递，减少样板代码	增加运行时开销	复杂应用，长调用链
自定义Future	完全控制，可优化性能	实现复杂	高性能要求的场景

7.3 可观测性最佳实践

请求追踪：为每个请求分配唯一ID，贯穿整个调用链
性能监控：记录关键操作的执行时间
错误处理：在上下文中包含错误处理和报告机制
日志关联：确保所有日志都包含上下文信息，便于问题排查

结论

Context与任务上下文传递是Rust异步编程中的核心概念。通过深入理解Context的设计原理和实现机制，我们可以构建出既安全又高效的异步应用。本文介绍的各种上下文传递模式和最佳实践，将帮助开发者在实际项目中做出合适的技术选择。

随着Rust异步生态的不断成熟，Context机制也在不断演进。未来，我们可以期待更优雅、更高效的上下文传递解决方案。掌握Context的使用技巧，将使我们能够充分发挥Rust在异步编程领域的优势，构建出高性能、可维护的现代应用。

在这里插入图片描述

AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

AI智能缺陷检测拦截致命错误的上线前防御体系构建

AtomGit开源社区

Chronos：把时间序列变成“语言”之后，预测问题会发生什么变化

AtomGit开源社区

【C++】类型系统：内置类型与自定义类型的对比

自定义类型（User-Defined Types）允许开发者根据需求创建新的数据类型，是构建复杂程序的基础。结构体（struct）：将不同类型的变量组合在一起代码语言：javascriptAI代码解释// 定义点结构体int x;int y;// 定义学生结构体int age;// 结构体嵌套联合体（union）：所有成员共享同一块内存空间代码语言：javascriptAI代码解释// 可存储不同