OC/Swift 技术 多线程 signal()跟wait()的用法

一直觉得自己写的不是技术，而是情怀，一个个的教程是自己这一路走来的痕迹。靠专业技能的成功是最具可复制性的，希望我的这条路能让你们少走弯路，希望我能帮你们抹去知识的蒙尘，希望我能帮你们理清知识的脉络，希望未来技术之巅上有你们也有我。

前言

这两个方法通常用于两个线程之间的通讯,通过结合使用 signal() 和 wait() 函数，你可以实现线程之间的同步和通信，以控制线程的执行顺序和共享资源的访问。

例如在电商项目里面有这样的一个需求,首页显示的时候需要请求3个接口,三个接口的数据回来了再去显示界面,就需要用到下面的方法来实现.

解决这样的需求其实还可以用NSOperation的方法来解决,下面会将来(操作间的依赖)

正题

Swift

class ViewController: UIViewController {
    
    let semaphore = DispatchSemaphore(value: 0)

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
       
        // 第一个线程
        DispatchQueue.global().async {
            print("线程1 开始执行")
            
            // 模拟耗时操作
            Thread.sleep(forTimeInterval: 2)
            
            print("线程1 执行完毕，发送信号")
            self.semaphore.signal()
        }

        // 第二个线程
        DispatchQueue.global().async {
            print("线程2 等待信号")
            
            self.semaphore.wait()
            
            print("线程2 收到信号，开始执行")
            
            // 模拟耗时操作
            Thread.sleep(forTimeInterval: 1)
            
            print("线程2 执行完毕")
            self.semaphore.signal() // 发送信号给主线程
        }

        // 主线程等待所有任务完成
        DispatchQueue.main.async {
            self.semaphore.wait()
            print("所有线程执行完毕")
        }

    }
 
}

OC

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

    // 第一个线程
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"线程1 开始执行");
        
        // 模拟耗时操作
        [NSThread sleepForTimeInterval:2];
        
        NSLog(@"线程1 执行完毕，发送信号");
        dispatch_semaphore_signal(semaphore);
    });

    // 第二个线程
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"线程2 等待信号");
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
        NSLog(@"线程2 收到信号，开始执行");
        
        // 模拟耗时操作
        [NSThread sleepForTimeInterval:1];
        
        NSLog(@"线程2 执行完毕");
        
        dispatch_semaphore_signal(semaphore); // 发送信号给主线程
    });

    // 主线程等待所有任务完成
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"所有线程执行完毕");
}

NSOperation(操作间的依赖)

@interface ViewController ()
@property (nonatomic,strong) NSOperationQueue *queue;
@end

@implementation ViewController

- (NSOperationQueue *)queue {
    if (_queue == nil) {
        _queue = [NSOperationQueue new];
    }
    return _queue;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];


}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    [self demo];
}

-(void)demo {
    // 创建登录操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"假装在登录...%@",[NSThread currentThread]);
    }];
    
    // 创建付费操作
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"假装在付费...%@",[NSThread currentThread]);
    }];
    
    // 创建下载操作
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"假装在下载...%@",[NSThread currentThread]);
    }];
    
    // 创建通知用户操作
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"假装在通知用户...%@",[NSThread currentThread]);
    }];
    
    // 创建操作间的依赖关系
    /*
     1.操作间的依赖可以跨队列建立
     2.不能在把操作添加到队列之后,再建立依赖关系.因为此时已经晚了.操作已经在执行了
     3.不可以循环依赖;现在只是死锁,老版本会崩溃
     */
    
    // 付费 依赖 登录
    [op2 addDependency:op1];
    [op3 addDependency:op2];
    [op4 addDependency:op3];
    
    // 批量把操作添加到队列
    // waitUntilFinished : 是否等到前面的异步任务执行结束之后,在执行后面的代码
    [self.queue addOperations:@[op1,op2,op3] waitUntilFinished:NO];
    
    // 把op4添加到主队列
    // 操作间的依赖可以跨队列建立
    [[NSOperationQueue mainQueue] addOperation:op4];
    
    NSLog(@"后面的代码");
}
@end