多线程随笔

===================

多线程

==================

 

多线程

一、概念：

程序：（Program）（App）是一个可以运行的文件（我们写的代码）

进程：（Process）是程序执行的一个操作实体

        即在系统中正在运行的一个应用程序

    每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内

    比如同时打开QQ、Xcode，系统就会分别启动2个进程

    通过“活动监视器”可以查看Mac系统中所开启的进程

01_iOS进程.png

02_进程和系统.png

线程：（Thread）线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行    

一个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）

    比如使用酷狗播放音乐、使用迅雷下载电影，都需要在线程中执行

03_进程和线程.png

二、背景：

    线程的串行

    1个线程中任务的执行是串行的

    如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务

    也就是说，在同一时间内，1个线程只能执行1个任务

    比如在1个线程中下载3个文件（分别是文件A、文件B、文件C）

 

当用户播放音频、下载资源、进行图像处理时往往希望做这些事情的时候其他操作不会被中断或者希望这些操作过程中更加顺畅。在单线程中一个线程只能做一件事情，一件事情处理不完另一件事就不能开始，这样势必影响用户体验。

耗时操作

  不依赖逻辑部分的东西

 

意义：

随着移动设备的更新换代，移动设备的性能也不断提高，现在流行的CPU已经进入双核、甚至四核时代。如何充分发挥这些CPU的性能，会变得越来越重要。在iOS中如果想要充分利用多核心CPU的优势，就要采用并发编程，提高CPU的利用率。

 

所以这节课学好了，会是面试的亮点

 

三、多线程

 

1.多线程原理

串行并行

04_线程的串并行.png

 

同一时间，CPU只能处理1条线程，只有1条线程在工作（执行）
多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）
如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象
思考：如果线程非常非常多，会发生什么情况？
CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源
每条线程被调度执行的频次会降低（线程的执行效率降低）

 

2.多线程的优缺点

 

多线程的优点

能适当提高程序的执行效率

能适当提高资源利用率（CPU、内存利用率）

 

多线程的缺点

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

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

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

 

3.多线程在iOS开发中的应用

 

主线程:一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”

主线程的主要作用

显示刷新UI界面

处理UI事件（比如点击事件、滚动事件、拖拽事件等）

主线程的使用注意:别将比较耗时的操作放到主线程中。

耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验

 

4.iOS的线程模型

pthread(底层C线程库)

NSThread（OC线程库）

NSOperationQueue（线程池/线程队列）

GCD（Blocks模式的线程池）

05_iOS线程模型.png

 

四、整体认知结束，详见代码

 

 

01_TimeConsumingAndPhread

 

这个工程告诉我们：

    //1.谁来响应我们的UI操作? 都是主线程响应

    //2.主线程处理任务,都是按照自然顺序处理,谁先来先处理谁,在一件事没有处理完成之前,这个家伙不会抽身去处理其他的事儿

    //3.currentThread 获得当前逻辑代码是运行在那一个线程中

    //4.主线程的number = 1 永远是 1

 

    //请问我们应该在主线程上执行什么样的操作呢?

    //主线程上执行的操作最好都是及时响应的,不能让用户觉得我们的程序像windows中的程序一样卡死了,这是一个很严重的用户体验问题

 

    //如果我真的需要完成一个非常耗时间的操作怎么办?

    //1.一定不要在主线程做这件事

    //2.开启一条新的线程(子线程),来完成耗时操作

    //3.常见耗时操作

    //大量的开模运算(数学类运算),图形运算,OpenGLES2.0(一般接触不到)

    //网络操作(1.网络环境影响(2G,2.5G,3G,4G相应速度都不同,大数据下载操作))

   

            pthread:C方法创建子线程

    pthread_t cThread;

    int b = pthread_create(&cThread, NULL, working, NULL);

缺点：不好写，不好控

优点：只是开个线程而已

 

 

 

02_NSThreadAndNSLock

 

这个工程告诉我们：

一、

    //NSThread 是 cocoa(MacOS,iOS)中一个轻量级的多线程对象

    //NSThread 傻瓜式的操作,简单

    //1.如何创建一个子线程

    //2.把耗时操作的逻辑转移到子线程中去

    //object 给 @selector中要执行的方法传递参数

    

//    //方法一

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

//    //可以给子线程命名

//    thread.name = @"子线程1";

//    //使用alloc创建的线程,一定要显示的调用start方法,才能够运行

//    [thread start];

    

    //方法二

    // 创建一个线程  只是创建就好 不亲自执行这个线程 只是创建

    // 线程创建后 就会自动运行

    //为了更加简化我们创建一个子线程的操作,NSObject对创建线程封装了一些方法

    //内部会自动的创建一个子线程,并且把@selector中的方法交给子线程去做

    [NSThread detachNewThreadSelector:@selector(doWCing) toTarget:self withObject:nil];

    

    //线程工作完程，如果以后不再使用这个线程

    //应当做如下操作

    //    [thread cancel];

    [NSThread exit];

 

二、

    //线程锁 类比上厕所，多个线程有一把锁就够了。谁锁，谁才能打开。

    NSLock * _threadLock;

    /**

     *  (atomic)。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。

     *

     //通过加锁和解锁，使一段代码成为原子操作。

     //使用线程锁，不是服务于线程，而是服务于代码。当我们希望一段代码进行原子操作，如数据库的写入，就可以进行加锁。

     //比如从判断缓存是否存在，到写入新的缓存。应当加一把线程锁。即使我们没有创建NSThread。

     //它和@Syncronized关键字起到同样效果。但是关键字不能在一个函数中加锁，另一个函数中解锁，NSLock可以。

     */

    //上锁

    [_threadLock lock];

    //解锁

    [_threadLock unlock];

 

三、

    //NSThread 很难人为的去控制创建子线程的数量

    //子线程创建过多,会严重的影响程序的性能,因为每一个线程都会占用一定cpu的资源,导致cpu很忙碌,特别是多人开发的时候

 

 

03_GCDDemo

 

这个工程告诉我们：

 

1.什么是GCD?

为并发代码在多核硬件(ios(iphone4s),mac os)上高效执行多线程代码而生的技术

弥补了NSThread难于管理的问题

//Grand Central Dispatch(多线程优化技术)或称GCD，是一套底层API，提供了新的模式编写并发执行的程序。允许将一个程序切分为多个单一任务，然后提交到工作队列并并发地或者串行地执行。

 

2.什么是Queue队列?

GCD使用了队列概念,已经很好的解决了NSThread难于管理的问题,队列实际上就是一个数组的概念,通常我们把要执行的任务,放到一个队列中去管理

//GCD采用队列的方式管理线程，不仅可以管理多线程，并发的任务，设置主线程，也通过任务队列的方式进行管理。

//所以说GCD的队列是任务队列，而不是线程队列。

 

3.什么是串行队列?

依次完成每一个任务

 

4.什么是并行队列?

好像所有的任务都是在同一时间执行的

 

5.mainqueue(主队列)串行队列,全局队列(Global Queue),自己创建队列

 

 

CGD存在的问题

1.纯c的代码,让很多面向对象程序员头疼

2.虽然已经很好的解决了NSThread难于管理的问题,但是还不是很好,当程序在某一个时间点上如果需要执行很多个好时操作,也会出现创建很多个线程的问题,导致系统性能出现问题

 

优点：

通过GCD，开发者不用再直接跟线程打交道了，只需要向队列中添加block代码即可，GCD在后端管理着一个线程池。GCD不仅决定着哪个线程(block)将被执行，它还根据可用的系统资源对线程池中的线程进行管理——这样可以不通过开发者来集中管理线程，缓解大量线程的创建，做到了让开发者远离线程的管理。

缺点：

虽然GCD是稍微偏底层的一个API，但是使用起来非常的简单。不过这也容易使开发者忘记并发编程中的许多注意事项和陷阱。

 

 

 

一、Dispatch Queues

 

    1.用户队列(用户队列，串行执行)：

    用户队列(GCD中对这种队列没有特定的名词来描述，姑且如此称之)可以使用dispatch_queue_create函数创建队列。这些队列是串行执行的。

    //怎么使用呢？

    //想要执行GCD的方法dispatch_async 必须把它交个一个队列管理,否则报错

    //dispatch_async 开一个子线程,不会阻塞主线程的操作，操作对象是线程，而不是方法

    //向队列中添加block任务

    //这是可以选择任务是同步执行还是异步执行

    //dispatch_async 函数会将传入的block块放入指定的queue里运行。这个函数是异步的，这就意味着它会立即返回而不管block是否运行结束。

    //同步，失去了多线程的意义，只不过是拿出来放在自己的队列里而已

    

    //把任务都添加在了同一队列（线程）queue上

    //所以自己创建的队列是串行的

 

 

 

    2.Global queues(全局队列，并行执行)：

    全局队列是并发队列，并由整个进程共享。进程中存在三个全局队列，可以调用dispatch_get_global_queue函数，传入优先级来访问队列。

 

    抓取全局的队列

    global_queue并行队列

    可以同时运行多个任务,每个任务的启动时间是按照加入queue的顺序,即任务开始执行的顺序和其加入队列的顺序相同，结束的顺序依赖各自的任务.我们自己不能去创建并行调度队列。只有三个可用的global concurrent queues。使用dispatch_get_global_queue获得

    //由于GCD中同一个队列中的任务是串行执行的。所以只要将那些需要线程保护的任务添加到同一个队列当中，就能实现串行执行。

 

 

3.The main queue(主队列，串行执行)：

    提交到main queue的任务将在主线程执行。main queue可以调用dispatch_get_main_queue()来获得。因为main queue是与主线程相关的，所以这是一个串行队列。

    //至少两个线程会调用这个函数，如果这个函数中有需要原子操作的代码，应当加线程锁，或者使用GCD进行保护

    

    //使用GCD保护

    //将需要保护的代码交由主线程执行。是主线程，也是主队列，一个队列的任务，是串行的。

PS:

还有一些其他的东西不需要了解的，工作基本不用，面试就说知道这个东西，但是不常用，如果需要可以细查查

讲这些只会加大我们的负担，影响学习心情和进度，意义不大

 

比如GCD的内存管理

比如GCD的线程阻碍等。。。

 

 

 

04_GCDMakeSingleton

 

GCD具有以下优点：

 

GCD 能通过推迟昂贵计算任务并在后台运行它们来改善你的应用的响应性能。

GCD 提供一个易于使用的并发模型而不仅仅只是锁和线程，以帮助我们避开并发陷阱。

GCD 具有在常见模式（例如单例）上用更高性能的原语优化你的代码的潜在能力。

 

 

单例模式是开发中最常用的写法之一，创建一个单例很多办法，iOS的单例模式有两种官方写法，如下：

 

不使用GCD

#import "ServiceManager.h"

 

static ServiceManager *defaultManager;

 

@implementation ServiceManager

 

+(ServiceManager *)defaultManager{

    if(!defaultManager)

    defaultManager=[[self allocWithZone:NULL] init];

    return  defaultManager;

}

 

@end

 

某些特殊情况下，if执行后面执行的慢了，然后另一个线程用了他，就会创建，if并不安全

 

使用GCD

#import "ServiceManager.h"

 

@implementation ServiceManager

 

+(ServiceManager *)sharedManager{

    static dispatch_once_t predicate;

    static ServiceManager * sharedManager;

    dispatch_once(&predicate, ^{

    sharedManager=[[ServiceManager alloc] init];

    });

    return sharedManager;

}

 

@end

 

dispatch_once这个函数，它可以保证整个应用程序生命周期中某段代码只被执行一次！

 

1. 线程安全。

2. 满足静态分析器的要求。

3. 兼容了ARC

 

我们看到，该方法的作用就是执行且在整个程序的声明周期中，仅执行一次某一个block对象。简直就是为单例而生的嘛。而且，有些我们需要在程序开头初始化的动作，如果为了保证其，仅执行一次，也可以放到这个dispatch_once来执行。

总结：1.这个方法可以在创建单例或者某些初始化动作时使用，以保证其唯一性。2.该方法是线程安全的，所以请放心大胆的在子线程中使用。（前提是你的dispatch_once_t *predicate对象必须是全局或者静态对象。这一点很重要，如果不能保证这一点，也就不能保证该方法只会被执行一次。）

 

 

//单例创建的写法

http://blog.csdn.net/lovefqing/article/details/8516536

//单例创建写法的原因

http://blog.sina.com.cn/s/blog_4cd8dd130101mi37.html

 

 ios 中如何实现一个真正的单利模式

 一个常见的担忧是它们常常不是线程安全的。这个担忧十分合理，基于它们的用途：单例常常被多个控制器同时访问。

 

 1.首先要保证allocWithZone是线程安全,当中调用super方法的时候使用dispatch_once方法锁住

 2.还要保证单利实现方法中也使用了dispatch_once方法锁住创建对象过程

 

        //dispatch_once的作用正如其名：对于某个任务执行一次，且只执行一次。 dispatch_once函数有两个参数，第一个参数predicate用来保证执行一次，第二个参数是要执行一次的任务block。

        //dispatch_once被广泛使用在单例、缓存等代码中，用以保证在初始化时执行一次某任务。

        //dispatch_once在单线程程序中毫无意义，但在多线程程序中，其低负载、高可依赖性、接口简单等特性，赢得了广大消费者的一致五星好评。

 

 

    //(mutableCopy深 与Copy浅，字面理解，能变的是深拷贝)

    //浅拷贝,就是只创建一个同类型对象返回

    //深拷贝就是,不但创建一个同类型对象回去,并且这个对象中所有的属性值一并都赋值过来

    //深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝

    //copy是创建一个新对象(copy 是内容拷贝)，retain是创建一个指针，引用对象计数加1(指针拷贝)

    //使用区别

    //mutableCopy得到一个新的可变对象，可以看到它的地址和原来对象的地址是不同的，也就是新对象的retainCount从0－1。

    //而copy得到的是一个不可变对象,这里分为两种情况：1、如果原来的对象也是一个不可变的，那么他们的地址指向同一个地址，也就是说它们同一个对象，只是把retainCount加1了而已，2、原来的对象是一个可变对象，那么它会新生成一个不可变对象，地址不同，也是retainCount从0－1。

 

 

05_NSOperationQueue

NSOperation使用方法

    iOS中有多种多线程实现方式,苹果公司建议我们都使用NSOperation技术

    1.GCD是纯c的对于面向对象程序员来说非常不友好

    2.GCD对线程的管理还不是很强大

 

    NSOperation底层实现就是基于GCD来做的

 

    dispatch_queue  == NSOperationQueue

    dispatch_asyn() == NSOperation

    dispatch_syn()  == NSOperation

 

 

    iOS并发编程中，把每个并发任务定义为一个Operation，对应的类名是NSOperation。NSOperation是一个抽象类，无法直接使用，它只定义了Operation的一些基本方法。我们需要创建一个继承于它的子类或者使用系统预定义的子类。目前系统预定义了两个子类：NSInvocationOperation和NSBlockOperation。

 

 

    NSInvocationOperation

        NSInvoationOperation是一个基于对象和selector的Operation，使用这个你只需要指定对象以及任务的selector，如果必要，你还可以设定传递的对象参数。

        NSInvocationOperation *invacationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomethingWithObj:) object:obj];

 

        同时当这个Operation完成后，你还可以获取Operation中Invation执行后返回的结果对象。

        id result = [invacationOperation result];

 

    NSBlockOperation

        在一个Block中执行一个任务，这时我们就需要用到NSBlockOperation。可以通过blockOperationWithBlock:方法来方便地创建一个NSBlockOperation：

        NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{

        //Do something here.

        }];

 

    运行一个Operation

        调用Operation的start方法就可以直接运行一个Operation。

        [operation start];

    取消一个Operation

        要取消一个Operation，要向Operation对象发送cancel消息：

        [operation cancel];

 

 

06_ThreadsCommunication

多种主线程的获取方式（即线程之间的通信）

 

//通过NSThread

    //假设是子线程执行该方法，如何回调主线程，修改UI

    [self performSelectorOnMainThread:@selector(finished) withObject:nil waitUntilDone:NO];

    //这个方法是NSObject的类别方法，所有对象都能调用。

    //当前线程回调主线程完成工作，第三个参数是如果传YES，则当前线程等待主线程完成这一工作后，继续执行，否则阻塞。如果传NO，则当前线程不阻塞。

 

 

//通过operationQueue

    //线程队列

    //通过这个方法找到主队列，将任务添加给主队列去完成，即可交付给主线程完成。

    NSOperationQueue * mainQueue = [NSOperationQueue mainQueue];

 

    [mainQueue addOperationWithBlock:^(void){

    NSLog(@"判断执行当前block的是否是主线程 %d",[NSThread isMainThread]);

    }];

 

//通过GCD

    dispatch_async(dispatch_get_main_queue(), ^(void){

    NSLog(@"主线程执行这里的语句");

    });