多线程研究

线程的研究使用：
应用App当前只存在1个线程情形：
1.
同步+(主线程)串行：死锁(类似断点暂停)
2.
同步+(普通)串行 / 同步+全局并行/同步+(普通)并行: 只激活主main线程(block事件 内外待执行级别相同有序进行即可(逻辑由上而下顺序))
3.异步+(主线程)串行：只激活主main线程(逻辑先执行外部指令再依次执行block事件内指令)

---

应用App当前存在2个线程情形：
4.异步+(普通)串行：激活1main线程+1个普通线程(1+1)

---

应用App当前存在多个线程情形：
5.异步+(普通)并行/ 异步+全局并行：激活1main线程+N个普通线程(1+N)

//步+行组合(指令元素块block)
- (void)syncTestWithQueue:(dispatch_queue_t)queue withBarrier:(BOOL)barrier {
    
    

    NSLog(@"1");
    dispatch_sync(queue,^{
    
    
        //((普通)串行+同步):block事件自然完成之前(block事件内的所有指令执行完成之前)(block事件所在的整个c函数调用指令执行完成之前cpu不会处理所在的c函数调用指令往后的同级别调用指令)(block事件所在的整个c函数调用指令执行完成之后cpu继续处理所在的c函数调用指令往后的同级别调用指令)(block事件 内外待执行级别相同有序进行即可)
        //(主线程)串行+同步:block事件所在的整个c函数指令直接出现阻塞效果(类似断点)(阻塞即暂停在(当前)前方状态下即调用处c函数指令不会触发执行一直中断)(即block事件不会触发且后面的逻辑事件均不触发)
        //同步+(普通)并行  ：只激活原来的默认主main线程签(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令的插入待执行级别等于block事件内的所有待执行指令的插入待执行级别)(block事件 内外待执行级别相同有序进行即可)
        //同步+全局并行:只激活原来的默认主main线程签(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令的插入待执行级别等于block事件内的所有待执行指令的插入待执行级别)(block事件 内外待执行级别相同有序进行即可)
        //
        NSLog(@"start 1");
        sleep(3);
        NSLog(@"end 1");
        NSLog(@"NSThread1=%@",[NSThread currentThread]);
    });

    NSLog(@"2");
    dispatch_sync(queue, ^{
    
    
        NSLog(@"start 2");
        sleep(3);
        NSLog(@"end 2");
        NSLog(@"NSThread2=%@",[NSThread currentThread]);
    });

    NSLog(@"3");
    dispatch_sync(queue, ^{
    
    
        NSLog(@"start 3");
        sleep(3);
        NSLog(@"end 3");
        NSLog(@"NSThread3=%@",[NSThread currentThread]);
    });

    NSLog(@"4");
    dispatch_sync(queue, ^{
    
    
        NSLog(@"start 4");
        sleep(3);
        NSLog(@"end 4");
        NSLog(@"NSThread4=%@",[NSThread currentThread]);
    });
    NSLog(@"5");
    NSLog(@"NSThread=%@",[NSThread currentThread]);

    //多读单写
//    if (barrier) {
    
    
//        dispatch_barrier_sync(queue, ^{
    
    
//            //指令块block事件(栅栏函数事件本身)
//            NSLog(@"barrier start 1");
//            sleep(3);
//            NSLog(@"barrier end 1");
//            NSLog(@"NSThread5=%@",[NSThread currentThread]);
//        });
//        NSLog(@"6");
//        dispatch_sync(queue, ^{
    
    
//            NSLog(@"start 5");
//            sleep(3);
//            NSLog(@"end 5");
//            NSLog(@"NSThread6=%@",[NSThread currentThread]);
//        });
//        NSLog(@"7");
//    }



}

//步+行组合(指令元素块block)
- (void)asyncTestWithQueue:(dispatch_queue_t)queue withBarrier:(BOOL)barrier {
    
    
    NSLog(@"1");
    dispatch_async(queue, ^{
    
    
        //(异步+(普通)串行):block事件内的所有待执行指令全部插入一个异线程签(与主main线程签有区别的另外线程签)(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令依旧有序插入主main线程(插入原来的默认线程签))
        //异步+(主线程)串行:只激活原来的默认主main线程签(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令先插入主main线程签(在外部所有同级别的其他同等指令插入完成之后)再依次插入block事件内的所有待执行指令进入主main线程签)
        //异步+(普通)并行:整个c函数调用指令呈现异步并行的特征则调用处激活全新的线程签(插入当前c函数调用指令本身的block事件内的所有待执行指令)(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令依旧有序插入主main线程(插入原来的默认线程签))
        //异步+(全局)并行:整个c函数调用指令呈现异步并行的特征则调用处激活全新的线程签(插入当前c函数调用指令本身的block事件内的所有待执行指令)(block事件外部与block事件所在的整个c函数调用指令同级别的其他同等指令依旧有序插入主main线程(插入原来的默认线程签))
        NSLog(@"start 1");
        sleep(3);
        NSLog(@"end 1");
        NSLog(@"NSThread1=%@",[NSThread currentThread]);
    });
    NSLog(@"2");
    dispatch_async(queue, ^{
    
    
        NSLog(@"start 2");
        sleep(3);
        NSLog(@"end 2");
        NSLog(@"NSThread2=%@",[NSThread currentThread]);
    });
    NSLog(@"3");
    dispatch_async(queue, ^{
    
    
        NSLog(@"start 3");
        sleep(3);
        NSLog(@"end 3");
        NSLog(@"NSThread3=%@",[NSThread currentThread]);
    });
    sleep(3);
    NSLog(@"4");

    NSLog(@"NSThread=%@",[NSThread currentThread]);

//    if (barrier) {
    
    
//        dispatch_barrier_async(queue, ^{
    
    
//            NSLog(@"barrier start 1");
//            sleep(3);
//            NSLog(@"barrier end 1");
//            NSLog(@"NSThread5=%@",[NSThread currentThread]);
//        });
//        NSLog(@"5");
//
//        dispatch_async(queue, ^{
    
    
//            NSLog(@"start 4");
//            sleep(3);
//            NSLog(@"end 4");
//            NSLog(@"NSThread6=%@",[NSThread currentThread]);
//        });
//        NSLog(@"6");
//
//
//    }

}

同步+(主线程)串行：死锁(类似断点暂停)

//主线程队列串行
    dispatch_queue_t mainSerialQueue = dispatch_get_main_queue();
    //(主线程)串行+同步
    [self syncTestWithQueue:mainSerialQueue withBarrier:YES];

同步+(普通)串行 / 同步+全局并行/同步+(普通)并行: 只激活主main线程(block事件 内外待执行级别相同有序进行即可(逻辑由上而下顺序))

//创建普通队列串行
    dispatch_queue_t serialQueue = dispatch_queue_create("串行", DISPATCH_QUEUE_SERIAL);
    //(普通)串行+同步
    [self syncTestWithQueue:serialQueue withBarrier:YES];

//创建队列全局并行
    dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //同步+全局并行
    [self syncTestWithQueue:globalConcurrentQueue withBarrier:YES];

//创建队列并行
    dispatch_queue_t concurrentQueue = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
    //同步+普通并行
    [self syncTestWithQueue:concurrentQueue withBarrier:YES];

3.异步+(主线程)串行：只激活主main线程(逻辑先执行外部指令再依次执行block事件内指令)

//主线程队列串行
    dispatch_queue_t mainSerialQueue = dispatch_get_main_queue();
    //(主线程)串行+异步
    [self asyncTestWithQueue:mainSerialQueue withBarrier:YES];

4.异步+(普通)串行：激活1main线程+1个普通线程(1+1)

//创建普通队列串行
    dispatch_queue_t serialQueue = dispatch_queue_create("串行", DISPATCH_QUEUE_SERIAL);
    //(普通)串行+异步
    [self asyncTestWithQueue:serialQueue withBarrier:YES];

5.异步+(普通)并行/ 异步+全局并行：激活1main线程+N个普通线程(1+N)

//创建队列并行
    dispatch_queue_t concurrentQueue = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
    //异步+普通并行
    [self asyncTestWithQueue:concurrentQueue withBarrier:YES];

//创建队列全局并行
    dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //异步+全局并行
    [self asyncTestWithQueue:globalConcurrentQueue withBarrier:YES];

---

异步+(普通)并行/ 异步+全局并行分析

线程使用8个方向：

线程概念

线程与进程

栅栏函数：