iOS 多线程 01

  • 进程

    • 进程是指在系统中正在运行的一个应用程序
  • 线程
    • 1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）
    • 1个线程中任务的执行是串行的(执行完上一个才能执行下一个)
  • 多线程
    • 1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务
    • 线程可以并行, 但是每个线程中的任务还是串行
  • 多线程原理
    • 多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）
  • 多线程优缺点
    • 优点

      • 能适当提高程序的执行效率
      • 能适当提高资源利用率（CPU、内存利用率）
    • 缺点
      • 线程越多，CPU在调度线程上的开销就越大
      • 如果开启大量的线程，会降低程序的性能
      • 程序设计更加复杂：比如线程之间的通信、多线程的数据共享
  • pthread

    • 类型: C语言中类型的结尾通常 _t/Ref，而且不需要使用 *
    • /*
参数:
1. 线程代号的地址
2. 线程的属性
3. 调用函数的指针
  - void *(*)(void *)
  - 返回值 (函数指针)(参数)
  - void * 和 OC 中的 id 是等价的
4. 传递给该函数的参数
返回值:
如果是0，表示正确
如果是非0，表示错误码
*/
NSString *str = @"jx";
pthread_t thid;
int res = pthread_create(&thid, NULL, &demo, (__bridge void *)(str));
if (res == 0) {
  NSLog(@"OK");
} else {
  NSLog(@"error %d", res);
}
  • NSThread
    • 一个NSThread对象就代表一条线程
  • 创建线程的几种方式
  • // 1.创建线程
 NJThread *thread = [[NJThread alloc] initWithTarget:self selector:@selector(demo:) object:@"jx"];
 // 设置线程名称 [thread setName:@"ljx"];
// 设置线程的优先级
// 优先级仅仅说明被CPU调用的可能性更大
  [thread setThreadPriority:1.0];
 // 2.启动线程 [thread start];
    - detach/performSelector
    + 优点：简单快捷
    + 缺点：无法对线程进行更详细的设置

```objc
// 1.创建线程
[NSThread detachNewThreadSelector:@selector(demo:) toTarget:self withObject:@"jx"];

// 1.创建线程
// 注意: Swift中不能使用, 苹果认为这个方法不安全
    [self performSelectorInBackground:@selector(demo:) withObject:@"jx"];
    

    • 

  • 线程状态
    • 

  • 

        启动线程
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
[thread start];

    // 进入就绪状态 ->         运行状态。当线程任务执行完毕，自动进入死亡状态

    阻塞（暂停）线程
    + (void)sleepUntilDate:(NSDate *)date;
    + (void)sleepForTimeInterval:(NSTimeInterval)ti;
    // 进入阻塞状态

    强制停止线程
    + (void)exit;
    // 进入死亡状态

注意：一旦线程停止（死亡）了，就不能再次开启任务

   如图：
    

    多线程的安全隐患
    

      

    • 被锁定的代码同一时刻只能有一个线程执行
      • 

    • 

      @synchronized(锁对象) { // 需要锁定的代码  }
      

      • 

    

    • 

  • 互斥锁的优缺点 优点：能有效防止因多线程抢夺资源造成的数据安全问题 缺点：需要消耗大量的CPU资源
    • 

  • 互斥锁注意点
    • 

  • 

      

    • 锁定1份代码只用1把锁，用多把锁是无效的
      • 

    • 锁定范围越大, 性能越差
      • 

    

    • 

  • 原子和非原子属性

      

    • atomic：线程安全，需要消耗大量的资源
      • 

    • nonatomic：非线程安全，适合内存小的移动设备
      • 

    

    • 

  • 自旋锁 & 互斥锁
    • 

  • 

      

    • 共同点 都能够保证同一时间，只有一条线程执行锁定范围的代码
      • 

    • 不同点

        

      • 互斥锁：如果发现有其他线程正在执行锁定的代码，线程会进入"休眠"状态，等待其他线程执行完毕，打开锁之后，线程会被"唤醒"
        • 

      • 自旋锁：如果发现有其他线程正在执行锁定的代码，线程会"一直等待"锁定代码执行完成！ 自旋锁更适合执行非常短的代码！
        • 

      

      • 

    

    • 

  • 线程间通信

      

    • 

        

      • 子线程做耗时操作, 主线程更新数据
        • 

      

      • 

    

    • 

  • 

    #import "ViewController.h"

@interface ViewController ()

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@end

@implementation ViewController

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{

    // 开启一个子线程下载图片
    [self performSelectorInBackground:@selector(downlod) withObject:nil];
}

- (void)downlod
{
    NSLog(@"%@", [NSThread currentThread]);
    // 1.下载图片
     NSURL *url = [NSURL URLWithString:@"http://pic.4j4j.cn/upload/pic/20130531/07ed5ea485.jpg"];
     NSData *data = [NSData dataWithContentsOfURL:url];
    // 2.将二进制转换为图片
    UIImage *image = [UIImage imageWithData:data];

    // 3.跟新UI
#warning 注意: 千万不要在子线程中更新UI, 会出问题

    /*
     waitUntilDone:
     YES: 如果传入YES, 那么会等待updateImage方法执行完毕, 才会继续执行后面的代码
     NO:  如果传入NO, 那么不会等待updateImage方法执行完毕, 就可以继续之后后面的代码
     */
    /*
    [self performSelectorOnMainThread:@selector(updateImage:) withObject:image waitUntilDone:NO];
     */

    // 开发中常用
//    [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES];

    // 可以在指定的线程中, 调用指定对象的指定方法
    [self performSelector:@selector(updateImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];

}

- (void)updateImage:(UIImage *)image
{
    NSLog(@"%@", [NSThread currentThread]);
    // 3.更新UI
    self.imageView.image = image;

}
    

    • 

  • GCD
    • 

  • GCD中有2个核心概念

      

    • 任务：执行什么操作
      • 

    • 队列：用来存放任务
      • 

    

    • 

  • 执行任务

      

    • 同步方法: dispatch_sync
      • 

    • 异步方法: dispatch_async
      • 

    • 同步和异步的区别

        

      • 同步：只能在当前线程中执行任务，不具备开启新线程的能力
        • 

      • 异步：可以在新的线程中执行任务，具备开启新线程的能力
        • 

      

      • 

    

    • 

  • 队列

      

    • 并发队列
      

        

      • 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
        • 

      • 并发功能只有在异步（dispatch_async）函数下才有效
        • 

      • 

        GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建
            使用dispatch_get_global_queue函数获得全局的并发队列
            dispatch_queue_t dispatch_get_global_queue(
            dispatch_queue_priority_t priority, //                    队列的优先级
            unsigned long flags); // 此参数暂时无用，用0即可

            获得全局并发队列
            dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

            全局并发队列的优先级
            #define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
            #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
            #define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
            #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
        

        • 

      

      • 

    • 

      串行队列
    * 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
      

      • 

    • 

              GCD中获得串行有2种途径
        使用dispatch_queue_create函数创建串行队列
        // 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
        dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL);

        使用主队列（跟主线程相关联的队列）
        主队列是GCD自带的一种特殊的串行队列
        放在主队列中的任务，都会放到主线程中执行
        使用dispatch_get_main_queue()获得主队列
        dispatch_queue_t queue = dispatch_get_main_queue();
      

      • 

    • 注意点

      同步和异步主要影响：能不能开启新的线程
      

        

      • 同步：只是在当前线程中执行任务，不具备开启新线程的能力
        • 

      • 异步：可以在新的线程中执行任务，具备开启新线程的能力
        • 

      

      并发和串行主要影响：任务的执行方式
      

        

      • 并发：允许多个任务并发（同时）执行
        • 

      • 串行：一个任务执行完毕后，再执行下一个任务
        • 

      

      • 

    • 各种任务队列搭配

        

      • 同步 + 串行 *
        • 

      • 同步 + 并发 *
        • 

      • 异步 + 串行 *
        • 

      • 异步 + 并发 *
        • 

      • 异步 + 主队列 *
        • 

      • 同步 + 主队列 *
        • 

        • 

      

      • 

    • GCD线程间通信
      • 

    • 

      dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行耗时的异步操作...
      dispatch_async(dispatch_get_main_queue(), ^{
        // 回到主线程，执行UI刷新操作
        });
});
      

      • 

    • GCD其它用法
      • 

    • 延时执行
      • 

    • 

      dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后执行这里的代码...
});
      

      • 

    • 一次性代码

        

      • 使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
        • 

      

      • 

    • 

      static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ // 只执行1次的代码(这里面默认是线程安全的) });
      

      • 

    • 

      快速迭代
      

      • 

    • 

      dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
    // 执行10次代码，index顺序不确定
});
      

      • 

    • barrier

        

      • 在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
        • 

      • 不能是全局的并发队列
        • 

      • 所有的任务都必须在一个队列中
        • 

      • 

        dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
        

        • 

      

      • 

    • 队列组
      • 

    • 

      dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});
      

      • 

    • iOS中多线程的实现方案

        

      • 如图：
        • 

      

      • 

    • 单例模式

        

      • 单例模式的作用
        

        - 可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问，从而方便地控制了实例个数，并节约系统资源

        

        • 

      • 单例模式的使用场合

          

        • 在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）
          • 

        

        • 

      • ARC中，单例模式的实现
        • 

      • 

        在.m中保留一个全局的static的实例
        static id _instance;

        重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全）
        + (instancetype)allocWithZone:(struct _NSZone *)zone
        {

            static dispatch_once_t onceToken;
            dispatch_once(&onceToken,^{
            _instance = [super allocWithZone:zone];
            });
             return _instance;
        }

        提供1个类方法让外界访问唯一的实例
        + (instancetype)sharedInstance
        {
            static dispatch_once_t onceToken;
            dispatch_once(&onceToken, ^{
            _instance = [[self alloc] init];
             });
            return _instance;
        }

        实现copyWithZone:方法
        - (id)copyWithZone:(struct _NSZone *)zone
        {
            return _instance;
        }
        注意点
            // 注意点: 单例是不可以继承的, 如果继承引发问题
            // 如果先创建父类, 那么永远都是父类
            // 如果先创建子类, 那么永远都是子类
        

        • 

      

      • 

    

    • 

				


				
时间： 2024-10-13 11:36:31 

		


		


	

	
	

		


		
iOS  多线程 01的相关文章


								

		

			

                iOS多线程实现方案详解01——NSThread
			

		

		

									

				NSThread 一.创建和启动线程 1.开线程的几种方式 1)先创建线程,后启动 NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil]; [thread start]; 2)创建线程后自动直接启动 [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil]; [sel			

		

	

				

		

			

                iOS多线程开发——NSThread浅析
			

		

		

									

				在IOS开发中,多线程的实现方式主要有三种,NSThread.NSOperation和GCD,我前面博客中对NSOperation和GCD有了较为详细的实现,可以参考<iOS多线程开发--NSOperation/NSOperationQueue浅析><iOS多线程开发--GCD的使用与多线程开发浅析>.以及对于多线程中的同步异步,并行串行等概念,我在<GCD实践--串行队列/并发队列与iOS多线程详解>中也有较为详细的讲解.为了学习的完整性,今天我们主要从代码层面来实现			

		

	

				

		

			

                iOS多线程开发小demo2，NSThread篇
			

		

		

									

				用NSThread创建子线程的3种方法 // DYFViewController.m // 623-02-pthread // // Created by dyf on 14-6-23. // Copyright (c) 2014年 ___FULLUSERNAME___. All rights reserved. // #import "DYFViewController.h" #import <pthread.h> @interface DYFViewController			

		

	

				

		

			

                iOS多线程编程--NSOperation（转）
			

		

		

									

				这篇文章写得非常不错,基础用法都涉及到了,我把文章提到的例子都写到了demo里面, 原文地址: iOS多线程--彻底学会多线程之『NSOperation』 demo下载:https://github.com/wangdachui/multithreading.git 1. NSOperation简介 NSOperation是苹果提供给我们的一套多线程解决方案.实际上NSOperation是基于GCD更高一层的封装,但是比GCD更简单易用.代码可读性也更高. NSOperation需要配合NSOp			

		

	

				

		

			

                iOS 多线程：『GCD』详尽总结
			

		

		

									

				本文用来介绍 iOS 多线程中 GCD 的相关知识以及使用方法.这大概是史上最详细.清晰的关于 GCD 的详细讲解+总结的文章了.通过本文,您将了解到: 1. GCD 简介 2. GCD 任务和队列 3. GCD 的使用步骤 4. GCD 的基本使用(6种不同组合区别) 5. GCD 线程间的通信 6. GCD 的其他方法(栅栏方法:dispatch_barrier_async.延时执行方法:dispatch_after.一次性代码(只执行一次):dispatch_once.快速迭代方法:dis			

		

	

				

		

			

                iOS 多线程 GCD part3:API
			

		

		

									

				https://www.jianshu.com/p/072111f5889d 2017.03.05 22:54* 字数 1667 阅读 88评论 0喜欢 1 0. 预备知识 GCD对时间的描述有些新奇 #define NSEC_PER_SEC 1000000000ull #define NSEC_PER_MSEC 1000000ull #define USEC_PER_SEC 1000000ull #define NSEC_PER_USEC 1000ull MSEC:毫秒 USEC:微秒 NSE			

		

	

				

		

			

                iOS多线程 GCD
			

		

		

									

				iOS多线程 GCD Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法. dispatch queue分成以下三种: 1)运行在主线程的Main queue,通过dispatch_get_main_queue获取. /*! * @function dispatch_get_main_queue * * @abstract * Returns the default queue that is bound to the main thread. *			

		

	

				

		

			

                iOS多线程编程
			

		

		

									

				1. 进程,线程, 任务 进程:一个程序在运行时,系统会为其分配一个进程,用以管理他的一些资源. 线程:进程内所包含的一个或多个执行单元称为线程,线程一般情况下不持有资源,但可以使用其所在进程的资源. 任务:进程或线程中要做的事情. 在引入线程的操作系统中,通常把进程作为分配资源的基本单位,而把线程作为独立运行和独立调度的基本单位. 线程比进程更小,对其调度的开销小,能够提高系统内多个任务的并发执行程度. 一个程序至少有一个进程,一个进程至少有一个线程.一个程序就是一个进程,而一个程序中的多个任			

		

	

				

		

			

                iOS.TextKit.01.凸版印刷效果
			

		

		

									

				1.案例视图,如下图 2.代码 TextKit01ViewController.h #import <UIKit/UIKit.h> @interface TextKit01ViewController : UIViewController @property (nonatomic,strong) IBOutlet UITextView *textView; // 文本可以排版的区域 @property (nonatomic,strong) NSTextContainer *textContai