多线程根本原理

线程和进程

  • 线程

    • 线程是进程的根本履行单元，一个进程的一切使命都在线程中履行
    • 进程想要履行使命，有必要至少有一条线程
    • 程序启动会默许敞开一条线程，也便是咱们常说的主线程也称为UI线程

  • 进程

    • 进程是指在体系中正在运⾏的⼀个应⽤程序，便是一段程序的履行过程，能够理解为手机上的一个app
    • 每个进程之间是独立的，每个进程均运转在其专用且受维护的内存空间内
    • 通过活动监视器能够检查MAC体系中一切敞开的进程

多线程的含义

  • 长处：

    • 能恰当进步程序的履行效率
    • 能恰当进步资源的利用率（CPU，内容）
    • 线程上的使命履行完成后，线程会主动毁掉

  • 缺点：

    • 敞开线程需求占用必定的内存空间（默许情况下，每一个线程都占512KB）
    • 假如敞开大量的线程，会占用大量的内存空间，降低程序的功能
    • 线程越多，CPU在调用线程上的开支就越大
    • 多线程使程序设计愈加复杂，比方线程间的通信、多线程的数据共享

多线程的原理

多线程是CPU在单位时刻的时刻片内来回调度和切换，构成了许多使命一起进行的假象

  • 单线程：
    • (单核CPU)同一时刻，CPU只能处理一个线程，换言之便是同一时刻只要一个线程在履行
  • 多线程：
    • CPU快速的在多个线程之间的切换，CPU调度线程的时刻足够快，就造成了多线程的一起履行作用
  • 假如线程数十分多：
    • CPU会在N个线程之间切换，消耗大量的CPU资源，每个线程被调度的次数就降低

线程的生命周期

多线程时CPU在多个线程之间来回切换，也便是有状况之分，当一个线程在被调度时，其他线程是的状况怎样的呢？于是就引出了线程的生命周期

  • 线程的生命周期分为5步：新建->组织妥当->运转->堵塞->逝世，如下图：

iOS多线程GCD(一)

  • 新建：
    • 运用new实例化一个线程目标，但该线程目标还未运用start()办法启动线程这个阶段，该阶段只在内存的堆中为该目标的实例变量分配了内存空间，但线程还无法参加争夺CPU的运用权。
  • 组织妥当：
    • 是指一个线程目标运用start()办法将线程参加可调度线程池后就进入组织妥当阶段，等候CPU来调度后才会履行
  • 运转：
    • 当CPU开端调度处于组织妥当状况的线程时，此刻线程才得以真实履行，即进入到运转状况。线程要想进入运转状况履行，首先有必要先处于处于组织妥当状况中。运转状况可能和组织妥当状况来回切换，这个和CPU调度有关。
  • 堵塞：
    • 处于运转状况中的线程由于某种原因例如(调用sleep、等候同步锁、从可调度线程池移出等)，此刻进入堵塞状况。
    • 例如：sleepForTimeInterval，sleepUntilDate函数，同步锁synchronized等可使线程进入堵塞状况
  • 逝世：
    • 正常逝世：线程履行结束
    • 非正常逝世：当线程因反常而退出，或许调用exit

可调度线程池

iOS多线程GCD(一)

  • 作原理是：

      1. 有新使命来时，会先判别线程池是否都在履行使命，假如没到就会创立线程履行使命
      1. 假如都在履行，就会检查工作行列是否丰满，假如未丰满，就会将使命存储在工作行列
      1. 假如丰满，则会判别线程是否都处于履行状况，假如没有，则组织非核心线程去履行
      1. 假如都在履行状况，则交给饱满战略处理。

  • 饱满战略

    • 饱满战略主要有4种：
      1. AbortPolicy：直接抛出RejectedExecutionExeception反常来阻止体系正常运转
      1. CallerRunsPolicy：将使命回退到调用者
      1. DisOldestPolicy：丢掉等候最久的使命
      1. DisCardPolicy：直接丢掉使命

  • 这四种回绝战略均由RejectedExecutionHandler接口完成

使命履行的影响因素

使命履行的影响因素一般有4种：

  • CPU
  • 使命的复杂度
  • 优先级
  • 线程状况

优先级

IO密集型的线程特点是频频等候，而CPU密集型则很少等候，所以CPU密集型的优先级要高，但优先级进步后也不必定履行，仅仅比低优先级的线程更可能运转，- 能够通过NSThread中的setThreadPriority:，或许POSIX的pthread_setschedparam办法来设置优先级

线程和runloop联系

    1. runloop与线程是⼀⼀对应的，⼀个runloop对应⼀个核⼼的线程，为什么说是核⼼的，是因为runloop是能够嵌套的，但是核⼼的只能有⼀个，他们的联系保存在⼀个大局的字典⾥
    1. runloop是来办理线程的，当线程的runloop被敞开后，线程回在履行完使命后进入休状况，有了使命就会被唤醒去履行使命
    1. runloop在第一次获取时被创立，在线程结束时被毁掉
    1. 关于主线程来说，runloop在程序一启动就默许创立好了
    1. 关于子线程来说，runloop是懒加载的，只要当咱们运用的时分才会创立，所以在子线程时用定时器要注意：保证子线程的runloop被创立，不然定时器就不会回调

多线程的完成计划

iOS多线程GCD(一)

GCD

    1. GCD全称是Grand Central Dispatch，纯C言语Api，提供了十分多的强大函数

    1. GCD优势：

      1. GCD是苹果公司为多核的并行运算提出的解决计划
      1. GCD会主动利用更多的CPU内核（如：双核、四核）
      1. GCD会主动办理线程的生命周期：创立线程、调度使命、毁掉线程，程序员只需求告知GCD想要履行什么使命，不需求编写任何线程办理代码

函数

  • 使命：GCD的使命运用block封装，block中没有参数也没有返回值 履行使命的函数：
  • 异步dispatch_async：不用等候当时句子履行结束，就能够履行下一条句子
    • 会敞开线程履行block的使命
    • 异步是多线程的代名词
  • 同步dispatch_sync：有必要等候当时句子履行结束，才会履行下一条句子
    • 不会敞开线程
    • 在当时线程履行block使命

行列

行列分为串行行列和并行行列，他们是一个数据结构，都遵从FIFO(先进先出)准则

串行行列

  • 串行行列在同一时刻只能履行一个使命，如图所示

iOS多线程GCD(一)

  • 在依据FIFO准则先进先出，所以后面的使命有必要等前面的使命履行结束才能履行，就导致串行行列是次序履行的

并行行列

  • 并行行列是一次能够调度多个使命，但并不必定都能履行，线程的状况有必要是runable时才能履行，所以先调度不必定先履行：

iOS多线程GCD(一)

函数与联系

函数与行列能够分为四种组合异步函数串行行列、并发行列异步函数、同步函数并发行列、同步函数串行行列

    1. 异步函数串行行列：敞开线程，使命一个接着一个
    1. 异步函数并发行列：敞开线程，在当时线程履行使命，使命履行没有次序，和cpu调度有关
    1. 同步函数并发行列：不会敞开线程，在当时线程履行使命，使命一个接着一个
    1. 同步函数串行行列：不会敞开线程，在当时线程履行使命，使命一个接着一个履行，会产生堵塞

主行列和大局行列

  • 主行列：专门在主线程上调度使命的串行行列，不会敞开线程，假如当时主线程正在履行使命，那么不管主行列中当时被添加了什么使命，都不会被调度dispatch_get_main_queue()
  • 大局行列：为了便利程序员的运用，苹果提供了大局行列dispatch_get_global_queue(0,0)，大局行列是并发行列，在运用多线程时，假如对行列没有特殊要求，在履行异步使命时，能够直接运用大局行列

iOS多线程GCD(一)

行列的源码探求

最新的源码libdispatch-1271.120.2

主行列

dispatch_get_main_queue

/*
 The main queue is meant to be used in application context to interact with the main thread and the main runloop.
 1.  主行列与程序的`主线程`和`runloop`进行交互
 2.  主行列在`main()`之前程序主动创立的
 Returns the main queue. This queue is created automatically on behalf of the main thread before main() is called.
*/
dispatch_queue_main_t
dispatch_get_main_queue(void)
{
    return DISPATCH_GLOBAL_OBJECT(dispatch_queue_main_t, _dispatch_main_q);
}
  • DISPATCH_GLOBAL_OBJECT函数，其间的有两个参数，第一个是类型，再来看看第二个参数_dispatch_main_q 
struct dispatch_queue_static_s _dispatch_main_q = {
    DISPATCH_GLOBAL_OBJECT_HEADER(queue_main),
#if !DISPATCH_USE_RESOLVERS
    .do_targetq = _dispatch_get_default_queue(true),
#endif
    .dq_state = DISPATCH_QUEUE_STATE_INIT_VALUE(1) |
  		DISPATCH_QUEUE_ROLE_BASE_ANON,
    .dq_label = "com.apple.main-thread",
    .dq_atomic_flags = DQF_THREAD_BOUND | DQF_WIDTH(1), 
    .dq_serialnum = 1,
    // 行列的区别可能与`dq_atomic_flags`和`dq_serialnum`两个参数有关，
    // 值分别为`DQF_THREAD_BOUND | DQF_WIDTH(1)`和`1`
};
大局行列

dispatch_get_global_queue

dispatch_queue_global_t
dispatch_get_global_queue(intptr_t identifier, uintptr_t flags);
// `identifier`能够设置一些`优先级`
// -   `flags`是留给将来运用，使命非`0`值都可能导致`NULL`，一般传`0`
dispatch_queue_global_t
dispatch_get_global_queue(intptr_t priority, uintptr_t flags)
{
    dispatch_assert(countof(_dispatch_root_queues) ==
         DISPATCH_ROOT_QUEUE_COUNT);
    if (flags & ~(unsigned long)DISPATCH_QUEUE_OVERCOMMIT) {
        return DISPATCH_BAD_INPUT;
    }
    dispatch_qos_t qos = _dispatch_qos_from_queue_priority(priority);
#if !HAVE_PTHREAD_WORKQUEUE_QOS
    if (qos == QOS_CLASS_MAINTENANCE) {
        qos = DISPATCH_QOS_BACKGROUND;
    } else if (qos == QOS_CLASS_USER_INTERACTIVE) {
        qos = DISPATCH_QOS_USER_INITIATED;
    }
#endif
    if (qos == DISPATCH_QOS_UNSPECIFIED) {
        return DISPATCH_BAD_INPUT;
    }
    return _dispatch_get_root_queue(qos, flags & DISPATCH_QUEUE_OVERCOMMIT);
}
  • 优先级，有四种：
      1. DISPATCH_QUEUE_PRIORITY_HIGH
      1. DISPATCH_QUEUE_PRIORITY_DEFAULT
      1. DISPATCH_QUEUE_PRIORITY_LOW
      1. DISPATCH_QUEUE_PRIORITY_BACKGROUND
// `_dispatch_get_root_queue`
static inline dispatch_queue_global_t
_dispatch_get_root_queue(dispatch_qos_t qos, bool overcommit)
{
     if (unlikely(qos < DISPATCH_QOS_MIN || qos > DISPATCH_QOS_MAX)) {
         DISPATCH_CLIENT_CRASH(qos, "Corrupted priority");
     }
     return &_dispatch_root_queues[2 * (qos - 1) + overcommit];
}
  • _dispatch_root_queues
    iOS多线程GCD(一)
    此刻找到了与dq_atomic_flags中相关参数DQF_WIDTH，传入的值为DISPATCH_QUEUE_WIDTH_POOL，也便是DQF_WIDTH(DISPATCH_QUEUE_WIDTH_FULL - 1)，但不能确认dq_serialnum，它的值跟label有关
自定义行列

行列的创立dispatch_queue_create

dispatch_queue_t
dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
{
    return _dispatch_lane_create_with_target(label, attr,
  		DISPATCH_TARGET_QUEUE_DEFAULT, true);
}
  • _dispatch_lane_create_with_target
static dispatch_queue_t
_dispatch_lane_create_with_target(const char *label, dispatch_queue_attr_t dqa,
  	dispatch_queue_t tq, bool legacy) // tq NULL,  legacy true
{
     dispatch_queue_attr_info_t dqai = _dispatch_queue_attr_to_info(dqa); // 面向目标封装
     ...
     dispatch_lane_t dq = _dispatch_object_alloc(vtable,
  		sizeof(struct dispatch_lane_s)); // 拓荒内存
     _dispatch_queue_init(dq, dqf, dqai.dqai_concurrent ?
  		DISPATCH_QUEUE_WIDTH_MAX : 1, DISPATCH_QUEUE_ROLE_INNER |
  		(dqai.dqai_inactive ? DISPATCH_QUEUE_INACTIVE : 0)); // 初始化
     dq->dq_label = label; //label赋值
     dq->dq_priority = _dispatch_priority_make((dispatch_qos_t)dqai.dqai_qos,
  		dqai.dqai_relpri);
     if (overcommit == _dispatch_queue_attr_overcommit_enabled) {
         dq->dq_priority |= DISPATCH_PRIORITY_FLAG_OVERCOMMIT;
     }
     if (!dqai.dqai_inactive) {
         dispatch_queue_priority_inherit_from_target(dq, tq);
   dispatch_lane_inherit_wlh_from_target(dq, tq);
     }
     _dispatch_retain(tq);
     dq->do_targetq = tq;
     _dispatch_object_debug(dq, "%s", __func__);
     return _dispatch_trace_queue_create(dq)._dq; // 创立痕迹标识，便利查找
}
  • 该函数第一个参数label咱们比较熟悉，便是创立的线程的姓名
  • _dispatch_queue_attr_to_info传入的第二参数：
dispatch_queue_attr_info_t
_dispatch_queue_attr_to_info(dispatch_queue_attr_t dqa)
{
    dispatch_queue_attr_info_t dqai = { }; // 初始为NULL，
    if (!dqa) return dqai;
    ...
}

  • 这里先初始一个dispatch_queue_attr_info_t类型目标，然后在依据dpa类型进行相关赋值，假如dqa为不存在则直接返回，这便是串行能够传NULL的原因

  • 做好相关的准备工作后，接着在调用_dispatch_object_alloc办法对线程拓荒内存

  • 再调用初始化函数_dispatch_queue_init，此处第三个参数有判别是否并判别，假如是并发传入为DISPATCH_QUEUE_WIDTH_MAX，串行则传入1，继续检查办法的完成：

iOS多线程GCD(一)

  • 此处能够看出又呈现了DQF_WIDTH()函数和dq_serialnum，并发DQF_WIDTH(DISPATCH_QUEUE_WIDTH_FULL - 2)，串行为DQF_WIDTH(1)，但依据行列类型传入的参数只和DQF_WIDTH有关，那么dq_serialnum是什么呢？

  • 查找_dispatch_queue_serial_numbers： unsigned long volatile _dispatch_queue_serial_numbers = DISPATCH_QUEUE_SERIAL_NUMBER_INIT; //

iOS多线程GCD(一)

  • 区别行列吗，还得看os_atomic_inc_orig函数的完成：

iOS多线程GCD(一)

  • 终究得到C++办法atomic_fetch_add_explicit是原子相关操作 ** 总结**
    1. 串行行列：DQF_WIDTH(1)
    1. 大局行列：DQF_WIDTH(DISPATCH_QUEUE_WIDTH_FULL - 1)
    1. 创立的并发行列：DQF_WIDTH(DISPATCH_QUEUE_WIDTH_FULL - 2)

行列的继承

行列的继承联系：dispatch_queue_t:dispatch_queue_s:dispatch_object_s