iOS：App切换时后台线程中OpenGL代码的暂停与恢复方案

首先得明确Apple文档的核心要求：绝对不能在App进入后台时让OpenGL操作处于执行状态——系统会在applicationDidEnterBackground:之后回收EAGLContext资源，如果此时还有GL操作在跑，轻则导致上下文状态混乱，重则直接崩溃。所以你的核心目标不是"挂起"任务，而是安全地停止新任务入队，等待正在执行的任务完成，之后在App恢复时重启任务。

下面分步骤给你可扩展的解决方案：

1. 核心原则：禁止强行中断正在执行的GL任务 #

GL是状态机模型，中途打断正在执行的glDrawArrays、glReadPixels等操作会导致上下文状态异常，后续再恢复时很难修复。所以必须：

• 阻止新的GL任务被提交到队列
• 等待队列中所有正在执行的任务自然完成
• 缓存暂停期间的新任务，恢复时重新提交

2. 基础实现：用开关+队列屏障控制任务流 #

针对你现有的glProcessingQueue，可以添加一个线程安全的状态开关，配合dispatch_barrier_sync来等待任务完成：

步骤1：添加状态控制变量 #

在你的类中添加原子布尔值（用os_unfair_lock保证线程安全，比synchronized更高效）：

#import <os/lock.h>

@interface YourViewController ()
@property (nonatomic, assign) os_unfair_lock taskLock;
@property (nonatomic, assign, getter=isGLTaskAllowed) BOOL glTaskAllowed;
@property (nonatomic, strong) dispatch_queue_t glProcessingQueue;
@property (nonatomic, strong) NSMutableArray *pendingGLTasks;
@end

@implementation YourViewController
- (instancetype)init {
    self = [super init];
    if (self) {
        _taskLock = OS_UNFAIR_LOCK_INIT;
        _glTaskAllowed = YES;
        _glProcessingQueue = dispatch_queue_create("com.yourapp.gl.processing", DISPATCH_QUEUE_SERIAL);
        _pendingGLTasks = [NSMutableArray array];
    }
    return self;
}

步骤2：修改任务提交逻辑 #

每次提交GL任务前，先检查状态，如果不允许则缓存任务：

- (void)submitGLTask:(void(^)(void))task {
    os_unfair_lock_lock(&_taskLock);
    if (!self.isGLTaskAllowed) {
        [_pendingGLTasks addObject:[task copy]];
        os_unfair_lock_unlock(&_taskLock);
        return;
    }
    os_unfair_lock_unlock(&_taskLock);
    
    dispatch_async(self.glProcessingQueue, ^{
        [EAGLContext setCurrentContext:self.eaglContext];
        task();
        [EAGLContext setCurrentContext:nil];
    });
}

步骤3：处理生命周期回调 #

在applicationWillResignActive:中，关闭开关并等待队列排空：

// 可以在AppDelegate或者你的ViewController中实现
- (void)applicationWillResignActive:(UIApplication *)application {
    os_unfair_lock_lock(&_taskLock);
    self.glTaskAllowed = NO;
    os_unfair_lock_unlock(&_taskLock);
    
    // 用barrier_sync等待队列中所有任务完成
    dispatch_barrier_sync(self.glProcessingQueue, ^{
        // 空block，仅用于等待队列任务全部执行完毕
    });
}

- (void)applicationDidBecomeActive:(UIApplication *)application {
    os_unfair_lock_lock(&_taskLock);
    self.glTaskAllowed = YES;
    NSArray *pendingTasks = [_pendingGLTasks copy];
    [_pendingGLTasks removeAllObjects];
    os_unfair_lock_unlock(&_taskLock);
    
    // 重新提交缓存的任务
    for (void(^task)(void) in pendingTasks) {
        [self submitGLTask:task];
    }
}

3. 可扩展设计：封装GL任务管理器 #

如果你的App有多个ViewController都在触发GL任务，最好把逻辑封装成单例的GLTaskManager，统一管理所有GL队列、任务状态和生命周期：

示例管理器实现 #

@interface GLTaskManager : NSObject
+ (instancetype)sharedManager;
// 提交GL任务，传入对应的EAGLContext（支持多上下文）
- (void)submitGLTask:(void(^)(EAGLContext *context))task forContext:(EAGLContext *)context;
// 生命周期回调方法
- (void)handleAppWillResignActive;
- (void)handleAppDidBecomeActive;
@end

@implementation GLTaskManager {
    // 每个EAGLContext对应一个串行队列（保证同一上下文的操作串行执行）
    NSMutableDictionary<NSValue *, dispatch_queue_t> *_contextQueues;
    NSMutableArray *_pendingTasks;
    BOOL _isAppActive;
    os_unfair_lock _lock;
}

+ (instancetype)sharedManager {
    static GLTaskManager *instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[GLTaskManager alloc] init];
    });
    return instance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _contextQueues = [NSMutableDictionary dictionary];
        _pendingTasks = [NSMutableArray array];
        _isAppActive = YES;
        _lock = OS_UNFAIR_LOCK_INIT;
    }
    return self;
}

- (dispatch_queue_t)queueForContext:(EAGLContext *)context {
    os_unfair_lock_lock(&_lock);
    NSValue *contextKey = [NSValue valueWithNonretainedObject:context];
    dispatch_queue_t queue = _contextQueues[contextKey];
    if (!queue) {
        NSString *queueName = [NSString stringWithFormat:@"com.yourapp.gl.context.%p", context];
        queue = dispatch_queue_create(queueName.UTF8String, DISPATCH_QUEUE_SERIAL);
        _contextQueues[contextKey] = queue;
    }
    os_unfair_lock_unlock(&_lock);
    return queue;
}

- (void)submitGLTask:(void(^)(EAGLContext *context))task forContext:(EAGLContext *)context {
    os_unfair_lock_lock(&_lock);
    if (!_isAppActive) {
        [_pendingTasks addObject:@{@"task": [task copy], @"context": context}];
        os_unfair_lock_unlock(&_lock);
        return;
    }
    os_unfair_lock_unlock(&_lock);
    
    dispatch_queue_t queue = [self queueForContext:context];
    dispatch_async(queue, ^{
        [EAGLContext setCurrentContext:context];
        task(context);
        [EAGLContext setCurrentContext:nil];
    });
}

- (void)handleAppWillResignActive {
    os_unfair_lock_lock(&_lock);
    _isAppActive = NO;
    os_unfair_lock_unlock(&_lock);
    
    // 等待所有上下文对应的队列排空
    for (dispatch_queue_t queue in _contextQueues.allValues) {
        dispatch_barrier_sync(queue, ^{});
    }
}

- (void)handleAppDidBecomeActive {
    os_unfair_lock_lock(&_lock);
    _isAppActive = YES;
    NSArray *pendingTasks = [_pendingTasks copy];
    [_pendingTasks removeAllObjects];
    os_unfair_lock_unlock(&_lock);
    
    for (NSDictionary *taskInfo in pendingTasks) {
        void(^task)(EAGLContext *) = taskInfo[@"task"];
        EAGLContext *context = taskInfo[@"context"];
        [self submitGLTask:task forContext:context];
    }
}

@end

使用方式 #

在AppDelegate中调用管理器的生命周期方法：

- (void)applicationWillResignActive:(UIApplication *)application {
    [[GLTaskManager sharedManager] handleAppWillResignActive];
}

- (void)applicationDidBecomeActive:(UIApplication *)application {
    [[GLTaskManager sharedManager] handleAppDidBecomeActive];
}

在任何ViewController中提交GL任务：

[[GLTaskManager sharedManager] submitGLTask:^(EAGLContext *context) {
    glViewport(0, 0, width, height);
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, renderedData);
} forContext:self.eaglContext];

关键注意事项 #

• 不要挂起队列：dispatch_suspend会直接暂停队列，但不会等待正在执行的任务完成，此时如果GL任务还在跑，系统进入后台后销毁Context会导致崩溃。
• 多上下文支持：如果你的App用了多个EAGLContext，每个Context必须对应独立的串行队列，避免不同线程同时操作同一Context（符合你提到的"同一Context同步执行"的要求）。
• 任务拆分（可选）：如果你的GL任务非常耗时，可以把任务拆分成多个小步骤，每个步骤开头检查_isAppActive状态，这样能更快响应暂停请求，但会增加代码复杂度。

内容的提问来源于stack exchange，提问作者ujjaval singh