播放器生命周期策略

什么是播放器生命周期策略？

播放器生命周期策略 (Player Lifecycle Strategy) 是用于管理播放器实例生命周期的架构机制。它定义了播放器实例的获取（acquire）、回收（recycle）、清理（clear）等核心操作，将播放器资源管理从业务代码中解耦出来。

不同的业务场景对播放器实例的管理有不同的需求：

策略模式的优势

通过策略模式管理播放器生命周期，带来以下核心优势：

• 解耦：业务代码无需关心播放器实例的创建和销毁细节。

• 灵活：运行时动态切换策略，无需修改业务代码。

• 可扩展：可实现自定义策略，满足特定业务需求。

• 可观测：统一的生命周期事件，便于监控和调试。

解决问题

1. 管理分散：播放器实例缺乏统一管控机制。

2. 性能损耗：频繁创建/销毁播放器导致资源浪费。

3. 复用障碍：跨场景无法复用播放器实例。

4. 内存失控：内存占用缺乏有效管控。

核心价值

架构优势：

• 策略解耦：播放器资源管理与业务逻辑分离，职责清晰。

• 运行时切换：无需重启即可切换策略实现。

• 线程安全：所有策略实现都支持多线程安全访问。

• 事件驱动：通过事件总线发布生命周期事件，便于监控。

核心能力

策略类型

AliPlayerKit 提供 4 种内置的播放器生命周期策略：

策略详解

DefaultLifecycleStrategy（默认策略）

最简单的策略，每次调用 acquire() 创建新实例，每次 recycle() 立即销毁。

特点：

• 无状态，每次都是全新实例。

• 无复用，适合简单场景。

• 内存占用最低（用完即释放）。

ReusePoolLifecycleStrategy（复用池策略）

基于对象池模式，维护空闲池和活跃列表。使用 LIFO（后进先出）策略复用实例。

特点：

• 空闲池 LIFO 策略，最近使用的实例优先复用。

• 支持预加载，提前创建实例。

• 池容量可配置，超出时销毁。

• 适合短视频列表、信息流场景。

IdScopedPoolLifecycleStrategy（ID 作用域策略）

为每个 uniqueId 维护独立的播放器实例。相同 uniqueId 始终返回同一实例。使用 LRU（最近最少使用）机制控制实例数量。

特点：

• ID 绑定，相同 ID 始终复用同一实例。

• LRU 淘汰机制，自动清理最近最少使用的实例。

• 支持预加载，提前创建未绑定实例。

• 适合视频预加载、多视频切换场景。

SingletonLifecycleStrategy（单例策略）

全局维护唯一一个播放器实例。无论 uniqueId 为何值，始终返回同一实例。

特点：

• 全局唯一，所有位置共享同一实例。

• 内存占用最低。

• 不适合多视频同时播放场景。

生命周期事件

策略执行过程中会发布生命周期事件，可通过事件总线监听：

使用默认策略

最简单的使用方式，无需额外配置：

// 创建控制器（自动使用 DefaultLifecycleStrategy）
AliPlayerController controller = new AliPlayerController(context);

// 绑定播放
AliPlayerModel model = new AliPlayerModel.Builder()
        .videoSource(videoSource)
        .build();
playerView.attach(controller, model);      

使用复用池策略

适合短视频列表、信息流场景：

// 获取复用池策略单例
ReusePoolLifecycleStrategy strategy = ReusePoolLifecycleStrategy.getInstance();

// 设置池容量（可选，默认为 3）
strategy.setMaxPoolSize(3);

// 创建控制器时注入策略
AliPlayerController controller = new AliPlayerController(context, strategy);

// 使用完毕后清理资源
strategy.clear(); 

使用 ID 作用域策略

适合需要预加载和多视频切换的场景：

// 获取 ID 作用域策略单例
IdScopedPoolLifecycleStrategy strategy = IdScopedPoolLifecycleStrategy.getInstance();

// 设置池容量
strategy.setMaxPoolSize(3);

// 预加载播放器实例（可选）
strategy.preload(context, 2);

// 创建控制器时注入策略
AliPlayerController controller = new AliPlayerController(context, strategy);

// 使用完毕后清理资源
strategy.clear(); 

使用单例策略

适合内存敏感场景：

// 获取单例策略实例
SingletonLifecycleStrategy strategy = SingletonLifecycleStrategy.getInstance();

// 预加载（可选，只创建一个实例）
strategy.preload(context, 1);

// 创建控制器时注入策略
AliPlayerController controller = new AliPlayerController(context, strategy);

如何监听生命周期事件？

通过事件总线监听策略内部的生命周期事件，用于调试和监控：

PlayerEventBus eventBus = PlayerEventBus.getInstance();

// 监听播放器创建
eventBus.subscribe(PlayerLifecycleEvents.PlayerCreated.class, event -> {
    Log.d("Player", "Created: " + event.playerId);
});

// 监听播放器复用
eventBus.subscribe(PlayerLifecycleEvents.PlayerReused.class, event -> {
    Log.d("Player", "Reused: " + event.playerId);
});

// 监听播放器淘汰
eventBus.subscribe(PlayerLifecycleEvents.PlayerEvicted.class, event -> {
    Log.d("Player", "Evicted: " + event.playerId);
});

// 监听播放器销毁
eventBus.subscribe(PlayerLifecycleEvents.PlayerDestroyed.class, event -> {
    Log.d("Player", "Destroyed: " + event.playerId);
});

// 不再需要时取消订阅
eventBus.unsubscribe(PlayerLifecycleEvents.PlayerCreated.class, listener);

如何动态切换策略？

运行时可以根据业务需求动态切换策略：

private IPlayerLifecycleStrategy mCurrentStrategy;

private void switchToReusePool() {
    // 1. 清理旧资源if (mCurrentStrategy != null) {
        mCurrentStrategy.clear();
    }

    // 2. 切换到复用池策略
    mCurrentStrategy = ReusePoolLifecycleStrategy.getInstance();
    mCurrentStrategy.setMaxPoolSize(3);

    // 3. 预加载
    mCurrentStrategy.preload(this, 2);
}

private void switchToSingleton() {
    // 1. 清理旧资源if (mCurrentStrategy != null) {
        mCurrentStrategy.clear();
    }

    // 2. 切换到单例策略
    mCurrentStrategy = SingletonLifecycleStrategy.getInstance();
}

如何预加载播放器实例？

预加载可以提前创建播放器实例，减少首帧耗时：

// 复用池策略：预加载实例放入空闲池
ReusePoolLifecycleStrategy strategy = ReusePoolLifecycleStrategy.getInstance();
strategy.preload(context, 2);  // 预创建 2 个实例// ID 作用域策略：预加载未绑定实例
IdScopedPoolLifecycleStrategy strategy = IdScopedPoolLifecycleStrategy.getInstance();
strategy.preload(context, 2);  // 预创建 2 个未绑定实例// 单例策略：预加载全局实例
SingletonLifecycleStrategy strategy = SingletonLifecycleStrategy.getInstance();
strategy.preload(context, 1);  // 创建全局实例（count 参数被忽略）

如何实现自定义策略？

通过继承 BaseLifecycleStrategy 实现自定义策略：

public class MyCustomStrategy extends BaseLifecycleStrategy {

    private final Map<String, IMediaPlayer> playerMap = new HashMap<>();

    @NonNull@Overridepublic IMediaPlayer acquire(@NonNull Context context, @NonNull String uniqueId) {
        // 自定义获取逻辑
        IMediaPlayer player = playerMap.get(uniqueId);
        if (player != null) {
            // 命中已有实例
            PlayerEventBus.getInstance().post(
                new PlayerLifecycleEvents.PlayerHit(player.getPlayerId()));
            return player;
        }

        // 创建新实例
        player = createPlayer(context);
        playerMap.put(uniqueId, player);
        return player;
    }

    @Overridepublic void recycle(@Nullable IMediaPlayer player, @NonNull String uniqueId, boolean force) {
        if (player == null) return;

        if (force) {
            // 强制销毁
            playerMap.remove(uniqueId);
            destroyPlayer(player);
        } else {
            // 仅停止，保留实例
            player.stop();
        }
    }

    @Overridepublic void clear() {
        // 清理所有实例for (IMediaPlayer player : playerMap.values()) {
            destroyPlayer(player);
        }
        playerMap.clear();
    }
}

策略选择指南

内存优化建议

每个播放器实例约占用 35~40MB 内存（基于阿里云微短剧多实例播放器池的内存 Profiling 结果），建议根据设备性能调整池容量：

// 根据设备内存动态调整
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
boolean isLowMemory = am.isLowRamDevice();

if (isLowMemory) {
    // 低内存设备使用单例策略
    strategy = SingletonLifecycleStrategy.getInstance();
} else {
    // 普通设备使用复用池策略
    strategy = ReusePoolLifecycleStrategy.getInstance();
    strategy.setMaxPoolSize(isHighEndDevice ? 3 : 2);
}

注意事项

示例功能

运行示例

在 Demo App 中选择 Lifecycle Strategy 示例查看效果。

核心接口

IPlayerLifecycleStrategy方法

BaseLifecycleStrategy方法

线程安全机制

池化策略对比

架构底层逻辑解析：

• ReusePool 为什么要用 LIFO（后进先出）？

  在 Feed 流上下滑动频繁的场景下，刚进入空闲池的播放器实例，其底层解码器上下文与硬件资源通常是最“热”的（缓存尚未被系统换页剥夺）。优先被唤醒，能够明显减少系统底层的上下文重置耗时，提升起播速度（基于空间局部性原理）。

• IdScopedPool 为什么要用 LRU（最近最少使用淘汰）？

  多实例池化存在“时间局部性”法则：随着用户浏览流推进，越久之前的视频立刻遭遇回放的概率越低。LRU 淘汰顺应了用户历史浏览轨迹的衰减规律，做到在完全绑定 ID 的前提下，仍能有效控制应用的内存峰值。

如何选择合适的策略？

根据业务场景选择：

• 简单播放场景：使用 Default 策略，无额外复杂度。

• 短视频/信息流：使用 ReusePool 策略，快速切换。

• 视频预加载：使用 IdScopedPool 策略，ID 绑定。

• 内存敏感：使用 Singleton 策略，最小占用。

池容量设置多少合适？

建议根据设备性能和业务需求调整：

• 每个播放器实例约占用 35~40MB内存。

• 默认池容量为 3，约占用 100~120MB。

• 低端设备建议设为 2 或使用 Singleton。

预加载何时使用？

预加载适用于需要减少首帧耗时的场景：

• 短视频列表：预加载 1~2 个实例。

• 视频详情页：预加载下一个推荐视频。

• 避免过多预加载：会增加内存占用。

高频崩溃错例

以下是客户反馈中最常导致问题的情况，请务必避免：

@Overrideprotected void onDestroy() {
    super.onDestroy();
    // 只解绑了 View，忘记清理策略持有的实例
    mPlayerView.detach();
}

@Overrideprotected void onDestroy() {
    super.onDestroy();
    // ✅ 解绑 View
    mPlayerView.detach();
    // ✅ 清理策略资源if (mStrategy != null) {
        mStrategy.clear();
    }
}

@Overrideprotected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 订阅了事件但从未取消
    PlayerEventBus.getInstance().subscribe(
        PlayerLifecycleEvents.PlayerCreated.class,
        event -> updateUI()
    );
}

private PlayerEventBus.EventListener<PlayerLifecycleEvents.PlayerCreated> mListener;

@Overrideprotected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mListener = event -> updateUI();
    PlayerEventBus.getInstance().subscribe(
        PlayerLifecycleEvents.PlayerCreated.class, mListener);
}

@Overrideprotected void onDestroy() {
    super.onDestroy();
    // 取消订阅if (mListener != null) {
        PlayerEventBus.getInstance().unsubscribe(
            PlayerLifecycleEvents.PlayerCreated.class, mListener);
    }
}

// 回收播放器
strategy.recycle(player, "video_1", false);

// 回收后继续使用
player.start();  // 可能导致异常

// 回收播放器
strategy.recycle(player, "video_1", false);
player = null;  // 清空引用，避免误用// 需要再次使用时，重新获取
player = strategy.acquire(context, "video_1");

如何调试？

1. 查看日志：使用 tag:AliPlayerKit 过滤 Logcat。

2. 监听生命周期事件：通过事件总线观察创建、复用、淘汰等动作。

3. 检查池状态：通过日志查看当前池大小和活跃实例数。

4. 内存分析：使用 Android Profiler 检查播放器实例数量和内存占用。