1.2 线程

• 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行
• 进程要想执行任务，必须得有线程，进程至少要有一条线程
• 程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程

1.3 进程和线程的关系

• 地址空间：同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。
• 资源拥有：同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间 的资源是独立的。
• 一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程 都死掉。所以多进程要比多线程健壮。
• 进程切换时，消耗的资源大，效率高。所以涉及到频繁的切换时，使用线程要好于进程。 同样如果要求同时进行并且又要共享某些变量的并发操作，只能用线程不能用进程
• 执行过程：每个独立的进程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
• 线程是处理器调度的基本单位，但是进程不是。

1.4 多进程

• 进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然程序是死的（静态的），进程是活动的（动态的）。
• 进程可以分为系统进程和用户进程。
  • 系统进程：凡是用于完成操作系统的各种功能的进程就是系统进程，他们就是出于运行状态下的操作系统本身
  • 用户进程：运行用户程序时创建的运行在用户态下的进程。
• 进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多进程。

1.5 多线程

• 同一时间，CPU 只能处理1条线程，只有1条线程执行。多线程并发执行，其实是CPU快速地在多条线程之间调度（切换）。如果CPU的调度线程的时间足够快，就造成了多线程并发执行的假象。

• 如果线程非常至多（N条），CPU会在这些（N条）线程之间调度，消耗大量的CPU资源，每条线程被调用执行的频率会降低（线程的执行效率降低），因此是有最佳线程数的计算的。

• 多线程的优点：

  • 能适当提高程序的执行效率
  • 能适当提高资源的利用率（CPU、内存利用率）

• 多线程的缺点：

  • 开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512kb），如若开启大量线程，会占用大量的内存空间，就会降低程序的性能

  • 线程越多，CPU在调度线程的开销就越大

  • 程序设计更加复杂：如线程之间的通信、多线程之间的数据共享等

1.6 任务

     就是执行操作的意思，也就是在线程中执行的那段代码。在DCD中是放在block 中的将要执行的代码。

     执行任务的方式有两种：同步执行（sync）和异步执行（async）

• 同步（Sync）: 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列中的任务都完成之后再执行，所以会阻塞线程。 只能在当前线程中执行任务（是当前的线程，不一定是主线程），不具备开启新线程的能力。

//创建同步任务(queue是队列)
dispatch_sync(queue, ^{
        
});

• 异步（Async）: 线程会立即返回，无需等待就会继续执行下面的任务，不会阻塞当前线程。可以在线的线程中执行任务，具备开启线程的能力（注：具备这个能力，但并不代表一定开启新的线程）。如果不是添加在主队列上，异步会在子线程中执行任务。

//创建异步任务(queue是队列)
dispatch_async(queue, ^{
        
});

1.7 队列

     队列（Dispatch Queue）: 这里的队列是指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，遵循 FIFO(先进先出) 的原则，即只能在队尾插入，队头删除。 没读取一个任务，则从队列中释放(删除)一个任务。

在GCD中有两种队列：串行队列和并发队列。两者都符合 FIFO 的原则，二者的主要区别是：执行的顺序不同和开启的线程数不同。

• 串行队列（Serial Dispatch Queue）:

  同一时间内，队列中只能执行一个任务，只有当前的任务执行完成之后，才能执行下一个任务。（只能开启一个线程，一个线程执行完毕后，再执行下一个任务）。

//第一个参数是队列的名字，自定义；第二个参数表示是串行还是并发
//DISPATCH_QUEUE_SERIAL = NULL，因此DISPATCH_QUEUE_SERIAL可以用NULL代替创建串行队列
dispatch_queue_t queue = dispatch_queue_create("shifx", DISPATCH_QUEUE_SERIAL);

• 主队列：是主线程上的一个串行队列，是系统自动为程序创建的。在主队列中调用不能在主线程再次调用同步任务，否则会造成堵塞，但是可以在其他线程中调用

• 并行队列（Concurrent Dispatch Queue）:

  同时允许多个任务同时执行。（可以开启多个线程，并且同时执行）。并发队列的并发功能只有在异步(dispatch_async) 函数下才有效。

//第一个参数是队列的名字，自定义；第二个参数表示是串行还是并发
dispatch_queue_t queue = dispatch_queue_create("shifx", DISPATCH_QUEUE_CONCURRENT);

• 全局队列：系统提供的并发队列

1.8 任务和队列

• 串行队列+同步执行
• 并发队列+同步执行
• 串行队列+异步执行
• 并发队列+异步执行
• 串行主队列
• 全局并发队列

1.8.1串行队列+同步执行

-(void)serialSysncText {
    //串行队列
    dispatch_queue_t serial = dispatch_queue_create("shifx", DISPATCH_QUEUE_SERIAL);
    NSLog(@"串行同步任务开始");
    dispatch_sync(serial, ^{
        sleep(1);
        for (int i = 0; i<3; i++) {
            NSLog(@"串行同步任务1 = %d",i);
        }
    });
    dispatch_sync(serial, ^{
        sleep(1);
        for (int i = 0; i<3; i++) {
            NSLog(@"串行同步任务2 = %d",i);
        }
    });
    NSLog(@"串行同步任务结束");
}

-(void)concurrentAsysncText {
    //并发队列
    dispatch_queue_t concurrent = dispatch_queue_create("shifx", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"并发同步任务开始");
    dispatch_sync(concurrent, ^{
        sleep(1);
        for (int i = 0; i<3; i++) {
            NSLog(@"并发同步任务1 = %d",i);
        }
    });
    dispatch_sync(concurrent, ^{
        sleep(1);
        for (int i = 0; i<3; i++) {
            NSLog(@"并发同步任务2 = %d",i);
        }
    });
    NSLog(@"并发同步任务结束");
}

-(void)serialAsysncText {
    //串行队列
    dispatch_queue_t serial = dispatch_queue_create("shifx", DISPATCH_QUEUE_SERIAL);
    NSLog(@"串行异步任务开始");
    dispatch_async(serial, ^{
        
        for (int i = 0; i<3; i++) {
            sleep(1);
            NSLog(@"串行异步任务1 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    dispatch_async(serial, ^{
        for (int i = 0; i<3; i++) {
            sleep(1);
            NSLog(@"串行异步任务2 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    NSLog(@"串行异步任务结束");
}

• 所有的异步任务都是在打印串行异步任务结束后才开始执行的；这意味着，异步任务是主线程开启的子线程中进行的。
• 从线程信息可以看到，开启了新的线程，但也只开启了一个线程；
• 在串行队列中的异步任务还是按照先后顺序执行的；

-(void)concurrentAsysncText {
    //并发队列
    dispatch_queue_t concurrent = dispatch_queue_create("shifx", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"并发异步任务开始");
    dispatch_async(concurrent, ^{
        for (int i = 0; i<3; i++) {
            sleep(1);
            NSLog(@"并发异步任务1 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    dispatch_async(concurrent, ^{
        
        for (int i = 0; i<3; i++) {
            sleep(1);
            NSLog(@"并发异步任务2 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    NSLog(@"并发异步任务结束");
}

• 所有的异步任务都是在打印并发异步任务结束后开始执行，这还是意味着，主线程开启型线程去执行异步任务。
• 由于有两个异步任务，所以并发队列就开了两个新的线程去执行，这一点从打印的线程编号也可以看出。
• 两个异步任务的执行是没有先后顺序的。

1.8.5 主队列+同步任务

//使用 NSThread 的 detachNewThreadWithBlock 方法会创建线程
[NSThread detachNewThreadWithBlock:^{
    [self mainSysncText];
}];
    
-(void)mainSysncText {
    NSLog(@"当前所在的线程：%@",[NSThread currentThread]);
    dispatch_sync(dispatch_get_main_queue(), ^{
        for (int i = 0; i<2; i++) {
            sleep(1);
            NSLog(@"主队列同步任务1 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(dispatch_get_main_queue(), ^{
        for (int i = 0; i<2; i++) {
            sleep(1);
            NSLog(@"主队列同步任务2 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
}

1.8.6 主队列+异步任务

-(void)mainAsysncText {
    NSLog(@"当前所在的线程：%@",[NSThread currentThread]);
    NSLog(@"主队列异步任务开始");
    dispatch_async(dispatch_get_main_queue(), ^{
        for (int i = 0; i<2; i++) {
            sleep(1);
            NSLog(@"主队列异步任务1 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        for (int i = 0; i<2; i++) {
            sleep(1);
            NSLog(@"主队列异步任务2 = %d",i);
            NSLog(@"当前线程：%@",[NSThread currentThread]);
        }
    });
    NSLog(@"主队列异步任务结束");
}

2、iOS中的多线程机制

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(testThread:) object:@"参数"];//使用初始化方法出来的线程需要手动启动
[thread start] //启动线程
thread.name = @"NsThread线程";
thread.threadPriority = 1; //设置优先级。范围0~1，表示执行概率，其值越大，表示该线程越容易被执行。由于是概率，并不能完全按照此实现想要的执行顺序
[thread cancel];//取消已经启动的线程
[NSThread detachNewThreadSelector:@selector(testThread:) toTarget:self withObject:@"构造器方法"];//使用构造器方式新建并启动一个线程

2.2.1 相关用法

// 获得主线程
+ (NSThread *)mainThread;    

// 判断是否为主线程(对象方法)
- (BOOL)isMainThread;

// 判断是否为主线程(类方法)
+ (BOOL)isMainThread;    

// 获得当前线程
NSThread *current = [NSThread currentThread];
//打印当前线程信息： NSLog(@"%@", [NSThread currentThread]); // 线程的名字——setter方法
- (void)setName:(NSString *)n;    

// 线程的名字——getter方法
- (NSString *)name;    

2.2.2 状态控制

//1.启动线程
- (void)start;
// 线程进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
//2.阻塞线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 线程进入阻塞状态
//3.强制停止线程，杀死线程
+ (void)exit;
// 线程进入死亡状态

2.2.3 线程通信

// 在主线程上执行操作
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray<NSString *> *)array;
  // equivalent to the first method with kCFRunLoopCommonModes

// 在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);

// 在当前线程上执行操作，调用 NSObject 的 performSelector:相关方法
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;

下面通过一个经典的下载图片 DEMO 来展示线程之间的通信。具体步骤如下：

1. 开启一个子线程，在子线程中下载图片。
2. 回到主线程刷新 UI，将图片展示在 UIImageView 中。

DEMO 代码如下：

/**
 * 创建一个线程下载图片
 */
- (void)downloadImageOnSubThread {
    // 在创建的子线程中调用downloadImage下载图片
    [NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];
}

/**
 * 下载图片，下载完之后回到主线程进行 UI 刷新
 */
- (void)downloadImage {
    NSLog(@"current thread -- %@", [NSThread currentThread]);
    
    // 1. 获取图片 imageUrl
    NSURL *imageUrl = [NSURL URLWithString:@"https://ysc-demo-1254961422.file.myqcloud.com/YSC-phread-NSThread-demo-icon.jpg"];
    
    // 2. 从 imageUrl 中读取数据(下载图片) -- 耗时操作
    NSData *imageData = [NSData dataWithContentsOfURL:imageUrl];
    // 通过二进制 data 创建 image
    UIImage *image = [UIImage imageWithData:imageData];
    
    // 3. 回到主线程进行图片赋值和界面刷新
    [self performSelectorOnMainThread:@selector(refreshOnMainThread:) withObject:image waitUntilDone:YES];
}

/**
 * 回到主线程进行图片赋值和界面刷新
 */
- (void)refreshOnMainThread:(UIImage *)image {
    NSLog(@"current thread -- %@", [NSThread currentThread]);
    
    // 赋值图片到imageview
    self.imageView.image = image;
}

2.2.4 线程安全和线程同步

• 线程安全：

• 线程同步：

/**
 * 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票
 */
- (void)initTicketStatusNotSave {
    // 1. 设置剩余火车票为 50
    self.ticketSurplusCount = 50;
    
    // 2. 设置北京火车票售卖窗口的线程
    self.ticketSaleWindow1 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketNotSafe) object:nil];
    self.ticketSaleWindow1.name = @"北京火车票售票窗口";
    
    // 3. 设置上海火车票售卖窗口的线程
    self.ticketSaleWindow2 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketNotSafe) object:nil];
    self.ticketSaleWindow2.name = @"上海火车票售票窗口";
    
    // 4. 开始售卖火车票
    [self.ticketSaleWindow1 start];
    [self.ticketSaleWindow2 start];

}

/**
 * 售卖火车票(非线程安全)
 */
- (void)saleTicketNotSafe {
    while (1) {
        //如果还有票，继续售卖
        if (self.ticketSurplusCount > 0) {
            self.ticketSurplusCount --;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%ld 窗口：%@", self.ticketSurplusCount, [NSThread currentThread].name]);
            [NSThread sleepForTimeInterval:0.2];
        }
        //如果已卖完，关闭售票窗口
        else {
            NSLog(@"所有火车票均已售完");
            break;
        }
    }
}

/**
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */
- (void)initTicketStatusSave {
    // 1. 设置剩余火车票为 50
    self.ticketSurplusCount = 50;
    
    // 2. 设置北京火车票售卖窗口的线程
    self.ticketSaleWindow1 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketSafe) object:nil];
    self.ticketSaleWindow1.name = @"北京火车票售票窗口";
    
    // 3. 设置上海火车票售卖窗口的线程
    self.ticketSaleWindow2 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketSafe) object:nil];
    self.ticketSaleWindow2.name = @"上海火车票售票窗口";
    
    // 4. 开始售卖火车票
    [self.ticketSaleWindow1 start];
    [self.ticketSaleWindow2 start];
    
}

/**
 * 售卖火车票(线程安全)
 */
- (void)saleTicketSafe {
    while (1) {
        // 互斥锁
        @synchronized (self) {
            //如果还有票，继续售卖
            if (self.ticketSurplusCount > 0) {
                self.ticketSurplusCount --;
                NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%ld 窗口：%@", self.ticketSurplusCount, [NSThread currentThread].name]);
                [NSThread sleepForTimeInterval:0.2];
            }
            //如果已卖完，关闭售票窗口
            else {
                NSLog(@"所有火车票均已售完");
                break;
            }
        }
    }
}

2.2.5 线程的状态转换

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];

     对于应用开发而言最最最常接触到就是互斥锁、递归锁这两种锁了，它们在API层面上又被封装为NSLock、NSRecursiveLock或者@synchronized语法了。这些锁通过保证线程同步访问的方式保护了资源从而解决了资源竞争的问题，但是它并不能完美解决并发编程中的所有问题，可能还会引发几个问题：

• 死锁（经典场景：使用互斥锁的线程加锁后又再次访问这个锁）
• 资源饥饿
• 线程优先级反转

2.2.2 GCD中任务与调度队列

• 创建/获取一个并发/串行的队列；
• 创建任务：确定要执行的事情，就是写匿名函数block，也就是要执行的代码块；
• 将任务加入到队列中：同时需要指定任务的执行方式，即同步还是异步。

    // 1.创建一个队列
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    // 2.创建一个任务
    dispatch_block_t block = ^{
        NSLog(@"%@",[NSThread currentThread]);
    };
    // 3.将任务添加进队列中（同时指定任务的执行方式）  
    dispatch_async(queue, block);

    dispatch_queue_t serial = dispatch_queue_create("A", DISPATCH_QUEUE_SERIAL);
    
    dispatch_queue_t conque = dispatch_queue_create("B", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_queue_t mainQueue = dispatch_get_main_queue();

    dispatch_queue_t globQueue = dispatch_get_global_queue(0, 0);

    NSLog(@"%@-%@-%@-%@",serial,conque,mainQueue,globQueue);

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

// @return 主队列
dispatch_queue_main_t dispatch_get_main_queue(void);       

/*!
 * @param identifier
 * 队列的服务质量，传0就是默认
 *
 * @param flags
 * 苹果留着以后用的，传0就行
 * 
 * @return dispatch_queue_global_t
 * 可以指定服务质量的系统定义的全局并发队列
 */
dispatch_queue_global_t dispatch_get_global_queue(long identifier, unsigned long flags);

typedef NSObject<OS_dispatch_queue> *dispatch_queue_t;

/*!
 * @param label
 * 给队列一个字符串标签进行唯一标识，以便在调试时区分队列
 * 建议使用反向DNS命名方式（com.example.myqueue）
 * 该参数可以为空（NULL）
 *
 * @param attr
 * 指定队列类型
 * DISPATCH_QUEUE_SERIAL     为串行队列
 * DISPATCH_QUEUE_CONCURRENT 为并发队列
 * 该参数可以为空（NULL），传空时默认为串行队列（在iOS4.3版本之前该参数只能传空）
 * 
 * @return dispatch_queue_t
 * 新创建的队列
 */
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);

// 创建一个串行队列 
dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", DISPATCH_QUEUE_SERIAL);
// 创建一个并发队列
dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", DISPATCH_QUEUE_CONCURRENT);
// 获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
			

				
			

/*!
 * @param queue
 * 需要获取label的队列;
 * 如果需要获取当前队列的label则使用 DISPATCH_CURRENT_QUEUE_LABEL
 * 
 * @return 
 * 创建队列时给队列设置的标签
 */
const char * dispatch_queue_get_label(dispatch_queue_t queue);

dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", NULL);
dispatch_sync(queue, ^{
   NSLog(@"%s", dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
});
NSLog(@"%s", dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
NSLog(@"%s", dispatch_queue_get_label(queue));
/*
com.junteng.myqueue
com.apple.main-thread
com.junteng.myqueue
 */

/*
 队列的特点：FIFO (First In First Out) 先进先出
 以下将 block（任务2）提交到主队列，主队列将来要取出这个任务放到主线程执行。
 而主队列此时已经有任务，就是执行（viewDidLoad方法），
 所以主队列要想取出 block（任务2），就要等上一个任务（viewDidLoad方法）先执行完，才能取出该任务执行。
 而 dispatch_sync 函数必须执行完 block（任务2）才会返回，才能往下执行代码。
 所以（任务2）要等待（viewDidLoad方法）执行完，（viewDidLoad方法）要等待（任务2）执行完。互相等待，就产生了死锁。
 */
- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"执行任务1");

    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"执行任务2");
    });

    NSLog(@"执行任务3");
}
/*
 打印：
 2020-01-19 00:16:26.980630+0800 多线程[25011:5507937] 执行任务1
 (lldb) 
 */

/*
 解决方案：打破（使用`dispatch_sync`函数往`当前串行队列`中添加任务）这一条件即可
 以下将（任务2）异步执行，打印结果为：132
 */
- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"执行任务1");

    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"执行任务2");
    });

    NSLog(@"执行任务3");
}
/*
 打印：
 2020-01-19 03:16:47.472682+0800 多线程[25416:5603048] 执行任务1
 2020-01-19 03:16:47.472890+0800 多线程[25416:5603048] 执行任务3
 2020-01-19 03:16:47.474389+0800 多线程[25416:5603048] 执行任务2
 */

• GCD是纯C语言的API，NSOperationQueue 则是基于GCD的OC版本封装。
• GCD只支持FIFO的队列，NSOperationQueue可以添加任务依赖，方便控制执行顺序
• 可以设定操作执行的优先级
• 任务执行状态控制:isReady,isExecuting,isFinished,isCancelled

• 可以设置最大并发量
• GCD的执行速度比NSOperationQueue 快

2.3.1 基本概念

/**
 NSInvocationOperation : 创建操作 ---> 创建队列 ---> 操作加入队列
 */
- (void)demo{
    //1:创建操作
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(handleInvocation:) object:@"123"];
    //2:创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    //3:操作加入队列 --- 操作会在新的线程中
    [queue addOperation:op];
}

- (void)handleInvocation:(id)op{
    NSLog(@"%@ --- %@",op,[NSThread currentThread]);
} 复制代码

2020-01-29 15:43:11.012492+0800 001---NSOperation初体验[1628:78932] 123 --- <NSThread: 0x600001ea9080>{number = 3,

/**
 手动调起操作
 */
- (void)demo1{
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(handleInvocation:) object:@"123"];
    // 注意 : 如果该任务已经添加到队列,你再手动调回出错
    // NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // [queue addOperation:op];
    // 手动调起操作,默认在当前线程
    [op start];
}

- (void)handleInvocation:(id)op{
    NSLog(@"%@ --- %@",op,[NSThread currentThread]);
} 复制代码

2020-01-29 15:52:55.404726+0800 001---NSOperation初体验[1740:83188] 123 --- <NSThread: 0x60000024e940>{number = 1, name = main} 复制代码

3.1  概念

/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0), // 进入 Run Loop 循环 (这里其实还没进入)
    kCFRunLoopBeforeTimers = (1UL << 1), // Run Loop 即将开始处理 Timer
    kCFRunLoopBeforeSources = (1UL << 2), // Run Loop 即将开始处理 Source
    kCFRunLoopBeforeWaiting = (1UL << 5), // Run Loop 即将进入休眠
    kCFRunLoopAfterWaiting = (1UL << 6), // Run Loop 从休眠状态唤醒
    kCFRunLoopExit = (1UL << 7), // Run Loop 退出（和 kCFRunLoop Entry 对应）
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};

#import <UIKit/UIKit.h>
#import "AppDelegate.h"

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
        NSLog(@"🏃🏃‍♀️🏃🏃‍♀️..."); // 这里插入一行打印语句
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
    // return 0;
    
    // 把上面的 return UIApplicationMain(argc, argv, nil, appDelegateClassName); 语句拆开如下：
    // int result = UIApplicationMain(argc, argv, nil, appDelegateClassName);
    // return result; // ⬅️ 在此行打一个断点，执行程序会发现此断点是无效的，因为 main 函数根本不会执行到这里
}

UIKIT_EXTERN int UIApplicationMain(int argc, char * _Nullable argv[_Nonnull], NSString * _Nullable principalClassName, NSString * _Nullable delegateClassName);