2016-12-12 16:50:27 ruglcc 阅读数 3519
  • 2018年下半年上午真题20-25

    1.学会分布式集群架构的设计思想及部署策略 2.掌握项目中第三方接入技术的实战应用 3.掌握使用Nexus搭建Maven私服 4.掌握如何基于微服技术Spring boot升级电商爱旅行项目

    1807课时 0分钟 389人学习 任铄
    免费试看
为什么要写这个系列,因为百度了一下,找了很多都是些片面的Blog,拷贝来拷贝去的,写的也很粗糙。

所以,我要写这个系列,尽量把官网文档中GCD的强大功能完整的表达出来。方便自己,也方便别人,如果发现有问题,欢迎提出


本教程的计划:在完整的看过GCD的官方文档之后,我实在想不出来如何用一篇文章详细完整的写出来如此多的功能。
所以,决定开一个专栏来写这个教程。计划8篇文章,分别介绍各种功能,每种功能会附上简单完整的示例代码。最后

的一篇文章会进行总结,总结出GCD的经典使用场景。源代码只提供Swift版本。因为要上班,计划一个月内完成。每周两篇。

原创Blog,转载请注明出处

这个专栏地址

http://blog.csdn.net/column/details/swift-gcd.html


GCD
全称:Grand Central Dispatch 
简介:GCD是对多线程、多核开发较完整的封装。在使用GCD的时候,系统会自动根据CPU使用情况进行调度,所以GCD是
一个简单易用,但是效果很好地多线程多核开发工具

要注意的地方:
1、慎用fork()函数(不是十分清楚流程不要用)
2、GCD是C语言级别的API,所以不会抓到异常,在一个提交到GCD的任务完成之前,应当处理完异常。


教程一

教程一涵盖了
1、GCD全局队列的四个优先级
2、几种本文使用到的GCD类型
3、dispatch_async/dispatch_async_f
4、dispatch_sync/dispatch_sync_f


一、概念与类型
对于GCD来说,所有的执行都放到队列中(queue),队列的特点是FIFO(先提交的先执行)。
GCD的队列分为几种,主队列(main),全局队列(global),用户创建队列(create)
对于全局队列,默认有四个,分为四个优先级
[cpp] view plain copy
  1. #define DISPATCH_QUEUE_PRIORITY_HIGH         2  
  2. #define DISPATCH_QUEUE_PRIORITY_DEFAULT      0  
  3. #define DISPATCH_QUEUE_PRIORITY_LOW          (-2)  
  4. #define DISPATCH_QUEUE_PRIORITY_BACKGROUND   INT16_MIN  


DISPATCH_QUEUE_PRIORITY_HIGH :优先级最高,在default,和low之前执行
DISPATCH_QUEUE_PRIORITY_DEFAULT 默认优先级,在low之前,在high之后
DISPATCH_QUEUE_PRIORITY_LOW 在high和default后执行
DISPATCH_QUEUE_PRIORITY_BACKGROUND:提交到这个队列的任务会在high优先级的任务和已经提交到background队列的执行完后执行。官方文档:(the queue is scheduled for execution after all high priority queues have been scheduled and the system runs items on a thread whose priority is set for background status.)


几种使用到的类型
[cpp] view plain copy
  1. typealias dispatch_queue_t = NSObject //轻量级的用来描述执行任务的队列  
  2. typealias dispatch_block_t = () -> Void //队列执行的闭包(Objective C中的block)  

几个概念
异步 提交的任务立刻返回,在后台队列中执行
同步 提交的任务在执行完成后才会返回
并行执行(全局队列) 提交到一个队列的任务,比如提交了任务1和任务2,在任务1开始执行,并且没有执行完毕时候,任务2就可以开始执行。
串行执行(用户创建队列) 提交到一个队列中的任务,比如提交了任务1和任务2,只有任务1结束后,任务2才可执行

注意:提交到队列中的任务是串行执行,还是并行执行由队列本身决定。

二、示例详解
[plain] view plain copy
  1. func dispatch_async(_ queue: dispatch_queue_t!,  
  2.                   _ block: dispatch_block_t!)  
参数:
queue 提交到的队列,队列的类型决定了是串行还是并行执行队列中的任务
block 执行的闭包
[plain] view plain copy
  1. func dispatch_async_f(_ queue: dispatch_queue_t!,  
  2.                     _ context: UnsafeMutablePointer<Void>,  
  3.                     _ work: dispatch_function_t)  
参数
queue 提交到的队列,队列的类型决定了是串行还是并行执行队列中的任务
context 传递给work的参数

work 执行的函数(C语言函数)

dispatch_sync 和 dispatch_sync的参数和上述对应一致,所以不再列出

总得来说带有后缀_f(比如dispatch_sync_f,dispatch_after_f)就是提交给队列一个C语言函数,因为极少用到这种形式,这里仅给出一个简单例子,后面的涉及到_f的都略过。

1、dispatch_async/dispatch_sync
功能:提交到队列中异步/同步执行
本示例:下载一张图片,图片下载完毕后通知UI改变
注意:要改变UI必须在主队列上执行
这里用到了一个获取全局队列的函数
[plain] view plain copy
  1. func dispatch_get_global_queue(_ identifier: Int,  
  2.                              _ flags: UInt) -> dispatch_queue_t!  
这个函数的第一个参数是队列的优先级,第二个参数尚没有意义,直接写0就可以了。

创建一个基于单页面的Swift工程,然后在ViewController.swift中,
[plain] view plain copy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()    
  5.         imageview.contentMode = UIViewContentMode.ScaleAspectFit    
  6.         self.view.addSubview(imageview)    
  7.         let url = "http://f.hiphotos.baidu.com/image/pic/item/e1fe9925bc315c60191d32308fb1cb1348547760.jpg"    
  8.         let imageURL = NSURL(string:url)     
  9.     var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)  
  10.     dispatch_async(globalQueueDefault){  
  11.         var imageData = NSData(contentsOfURL:imageURL!)  
  12.         var image = UIImage(data:imageData!)  
  13.         if let successfulImage = image{  
  14.             sleep(2)  
  15.             dispatch_async(dispatch_get_main_queue()){  
  16.                 self.imageview.image = successfulImage  
  17.             }  
  18.         }  
  19.     }  
  20.     }    
  21.     override func didReceiveMemoryWarning(){    
  22.         super.didReceiveMemoryWarning()    
  23.     }    
  24. }    
执行,观察下效果:view立刻载入,然后过一段时间,图片下载完了,UI改变
然后,我们观察dispatch_sync
只需要修改这一行即可

[plain] view plain copy
  1. dispatch_sync(globalQueueDefault,0){  

执行,观察下效果:view载入很慢,但是在载入的时候,图片下载完了。UI已经改变。可以打在这一行打断点,会发现异步执行会立刻返回,同步执行会等待执行结束后返回。
所以,当我们有一件非常耗时的事情,放到后台队列中去做,等做完了通知UI改变,是不会阻塞UI,降低用户体验的。


2、dispatch_async_f/dispatch_sync_f

简单的实例,把一个C函数提交给队列
首先,建立一个基于单页面的swift工程,命名为testForCSDN,然后再新建一个C语言文件,命名为hwcText->点击包括头文件->点击包含Bridging-Header.h
这样,工程里多了三个文件
hwcTest.c
hwcTest.h
testForCSDN-Bridging-Header.h
附上完整的代码
testForCSDN-Bridging-Header.h
[cpp] view plain copy
  1. #import "hwcTest.h"  

hwcTest.h
[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. typedef void (*hwcTestForGCD)(void*);  
  4. hwcTestForGCD getFuncPointer();  

hwcTest.c
[cpp] view plain copy
  1. #include "hwcTest.h"  
  2. void realFunction(void *input){  
  3.     for(int i = 0;i < 5;i++){  
  4.         printf("%d\n",i);  
  5.         sleep(1);  
  6.     }  
  7. }  
  8. hwcTestForGCD getFuncPointer(){  
  9.     return realFunction;  
  10. }  
ViewController.swift
[plain] view plain copy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()    
  5.         var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)  
  6.     dispatch_async_f(globalQueueDefault,nil,getFuncPointer())  
  7.     println("dispatch is over")  
  8.     }    
  9.     override func didReceiveMemoryWarning(){    
  10.         super.didReceiveMemoryWarning()    
  11.     }    
  12. }   
然后执行,会发现输出
[plain] view plain copy
  1. 0  
  2. dispatch is over  
  3. 1  
  4. 2  
  5. 3  
  6. 4  

然后,我们同样改成dispatch_sync后执行,发现输出
[plain] view plain copy
  1. 0  
  2. 1  
  3. 2  
  4. 3  
  5. 4  
  6. 5  
  7. dispatch is over  
这里更能体会到了,什么是同步,什么是异步了吧。


三、理解下并行队列和串行队列
使用一或者二中的工程都可以,修改ViewController.swft中的代码就可以
这里用到了一个函数
[plain] view plain copy
  1. func dispatch_queue_create(_ label: UnsafePointer<Int8>,  
  2.                          _ attr: dispatch_queue_attr_t!) -> dispatch_queue_t!  
参数
label String类型的队列标示符,通常取做com.companyname.productname.functionname
attr    两种类型。DISPATCH_QUEUE_SERIAL创建一个顺序执行队列, DISPATCH_QUEUE_CONCURRENT创建同时执行队列


ViewController的完整代码,这里提交两个任务,通过输出来判断是并行队列,还是串行队列

[plain] view plain copy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()   
  5.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){  
  6.         for var i = 0;i < 5;i++ {  
  7.             NSLog("First task:%d",i)  
  8.             sleep(1)  
  9.         }  
  10.     }  
  11.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){  
  12.         for var j = 0;j < 5;j++ {  
  13.             NSLog("Second task:%d",j)  
  14.             sleep(1)  
  15.         }  
  16.     }  
  17.     println("dispatch is over")  
  18.     }    
  19.     override func didReceiveMemoryWarning(){    
  20.         super.didReceiveMemoryWarning()    
  21.     }    
  22. }   

这里执行输出为:

[plain] view plain copy
  1. First task:0  
  2. Second task:0  
  3. First task:1  
  4. Second task:1  
  5. First task:2  
  6. Second task:2  
  7. First task:3  
  8. Second task:3  
  9. First task:4  
  10. Second task:4  
这段代码执行时间4.03s


然后,我们使用串行执行的队列
[plain] view plain copy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()  
  5.     var serialQueue =  dispatch_queue_create(label:   
  6.   
  7.   
  8. "com.test.helloHwc",attr:DISPATCH_QUEUE_SERIAL)  
  9.     dispatch_async(serialQueue){  
  10.         for var i = 0;i < 5;i++ {  
  11.             NSLog("First task:%d",i)  
  12.             sleep(1)  
  13.         }  
  14.     }  
  15.     dispatch_async(serialQueue){  
  16.         for var j = 0;j < 5;j++ {  
  17.             NSLog("Second task:%d",j)  
  18.                         sleep(1)  
  19.         }  
  20.     }  
  21.     println("dispatch is over")  
  22.     }    
  23.     override func didReceiveMemoryWarning(){    
  24.         super.didReceiveMemoryWarning()    
  25.     }    
  26. }   

这里输出为

[plain] view plain copy
  1. First task:0  
  2. First task:1  
  3. First task:2  
  4. First task:3  
  5. First task:4  
  6. Second task:0  
  7. Second task:1  
  8. Second task:2  
  9. Second task:3  
  10. Second task:4  
这段代码执行时间8.06秒

看出来并行和串行执行的差别了吧。

所以,记住一点,把过程不相关的任务,提交到并行的队列中会显著提高效率

下一篇预计更新时间,本周末

BTY:如果图片下载失败,可能因为时间的原因,那张图片从服务器上删除了,自己找一个URL即可

原图



2014-11-13 08:28:12 Hello_Hwc 阅读数 20021
  • 2018年下半年上午真题20-25

    1.学会分布式集群架构的设计思想及部署策略 2.掌握项目中第三方接入技术的实战应用 3.掌握使用Nexus搭建Maven私服 4.掌握如何基于微服技术Spring boot升级电商爱旅行项目

    1807课时 0分钟 389人学习 任铄
    免费试看


/////-------------注意----------------

这篇文章是在Swift 1.0时代写的,已经不适合当前的语法。关于Swift最新版本的GCD,参见我的这篇博客

/////-------------注意----------------


为什么要写这个系列,因为百度了一下,找了很多都是些片面的Blog,拷贝来拷贝去的,写的也很粗糙。

所以,我要写这个系列,尽量把官网文档中GCD的强大功能完整的表达出来。方便自己,也方便别人,如果发现有问题,欢迎提出


本教程的计划:在完整的看过GCD的官方文档之后,我实在想不出来如何用一篇文章详细完整的写出来如此多的功能。
所以,决定开一个专栏来写这个教程。计划8篇文章,分别介绍各种功能,每种功能会附上简单完整的示例代码。最后

的一篇文章会进行总结,总结出GCD的经典使用场景。源代码只提供Swift版本。因为要上班,计划一个月内完成。每周两篇。

原创Blog,转载请注明出处

这个专栏地址

http://blog.csdn.net/column/details/swift-gcd.html


GCD
全称:Grand Central Dispatch 
简介:GCD是对多线程、多核开发较完整的封装。在使用GCD的时候,系统会自动根据CPU使用情况进行调度,所以GCD是
一个简单易用,但是效果很好地多线程多核开发工具

要注意的地方:
1、慎用fork()函数(不是十分清楚流程不要用)
2、GCD是C语言级别的API,所以不会抓到异常,在一个提交到GCD的任务完成之前,应当处理完异常。


教程一

教程一涵盖了
1、GCD全局队列的四个优先级
2、几种本文使用到的GCD类型
3、dispatch_async/dispatch_async_f
4、dispatch_sync/dispatch_sync_f


一、概念与类型
对于GCD来说,所有的执行都放到队列中(queue),队列的特点是FIFO(先提交的先执行)。
GCD的队列分为几种,主队列(main),全局队列(global),用户创建队列(create)
对于全局队列,默认有四个,分为四个优先级
#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


DISPATCH_QUEUE_PRIORITY_HIGH :优先级最高,在default,和low之前执行
DISPATCH_QUEUE_PRIORITY_DEFAULT 默认优先级,在low之前,在high之后
DISPATCH_QUEUE_PRIORITY_LOW 在high和default后执行
DISPATCH_QUEUE_PRIORITY_BACKGROUND:提交到这个队列的任务会在high优先级的任务和已经提交到background队列的执行完后执行。官方文档:(the queue is scheduled for execution after all high priority queues have been scheduled and the system runs items on a thread whose priority is set for background status.)


几种使用到的类型
typealias dispatch_queue_t = NSObject //轻量级的用来描述执行任务的队列
typealias dispatch_block_t = () -> Void //队列执行的闭包(Objective C中的block)

几个概念
异步 提交的任务立刻返回,在后台队列中执行
同步 提交的任务在执行完成后才会返回
并行执行(全局队列) 提交到一个队列的任务,比如提交了任务1和任务2,在任务1开始执行,并且没有执行完毕时候,任务2就可以开始执行。
串行执行(用户创建队列) 提交到一个队列中的任务,比如提交了任务1和任务2,只有任务1结束后,任务2才可执行

注意:提交到队列中的任务是串行执行,还是并行执行由队列本身决定。

二、示例详解
func dispatch_async(_ queue: dispatch_queue_t!,
                  _ block: dispatch_block_t!)
参数:
queue 提交到的队列,队列的类型决定了是串行还是并行执行队列中的任务
block 执行的闭包
func dispatch_async_f(_ queue: dispatch_queue_t!,
                    _ context: UnsafeMutablePointer<Void>,
                    _ work: dispatch_function_t)
参数
queue 提交到的队列,队列的类型决定了是串行还是并行执行队列中的任务
context 传递给work的参数

work 执行的函数(C语言函数)

dispatch_sync 和 dispatch_sync的参数和上述对应一致,所以不再列出

总得来说带有后缀_f(比如dispatch_sync_f,dispatch_after_f)就是提交给队列一个C语言函数,因为极少用到这种形式,这里仅给出一个简单例子,后面的涉及到_f的都略过。

1、dispatch_async/dispatch_sync
功能:提交到队列中异步/同步执行
本示例:下载一张图片,图片下载完毕后通知UI改变
注意:要改变UI必须在主队列上执行
这里用到了一个获取全局队列的函数
func dispatch_get_global_queue(_ identifier: Int,
                             _ flags: UInt) -> dispatch_queue_t!
这个函数的第一个参数是队列的优先级,第二个参数尚没有意义,直接写0就可以了。

创建一个基于单页面的Swift工程,然后在ViewController.swift中,
class ViewController: UIViewController{  
    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))  
    override func viewDidLoad(){  
        super.viewDidLoad()  
        imageview.contentMode = UIViewContentMode.ScaleAspectFit  
        self.view.addSubview(imageview)  
        let url = "http://f.hiphotos.baidu.com/image/pic/item/e1fe9925bc315c60191d32308fb1cb1348547760.jpg"  
        let imageURL = NSURL(string:url)   
	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)
	dispatch_async(globalQueueDefault){
		var imageData = NSData(contentsOfURL:imageURL!)
		var image = UIImage(data:imageData!)
		if let successfulImage = image{
			sleep(2)
			dispatch_async(dispatch_get_main_queue()){
				self.imageview.image = successfulImage
			}
		}
	}
    }  
    override func didReceiveMemoryWarning(){  
        super.didReceiveMemoryWarning()  
    }  
}  
执行,观察下效果:view立刻载入,然后过一段时间,图片下载完了,UI改变
然后,我们观察dispatch_sync
只需要修改这一行即可

dispatch_sync(globalQueueDefault,0){

执行,观察下效果:view载入很慢,但是在载入的时候,图片下载完了。UI已经改变。可以打在这一行打断点,会发现异步执行会立刻返回,同步执行会等待执行结束后返回。
所以,当我们有一件非常耗时的事情,放到后台队列中去做,等做完了通知UI改变,是不会阻塞UI,降低用户体验的。


2、dispatch_async_f/dispatch_sync_f

简单的实例,把一个C函数提交给队列
首先,建立一个基于单页面的swift工程,命名为testForCSDN,然后再新建一个C语言文件,命名为hwcText->点击包括头文件->点击包含Bridging-Header.h
这样,工程里多了三个文件
hwcTest.c
hwcTest.h
testForCSDN-Bridging-Header.h
附上完整的代码
testForCSDN-Bridging-Header.h
#import "hwcTest.h"

hwcTest.h
#include <stdio.h>
#include <unistd.h>
typedef void (*hwcTestForGCD)(void*);
hwcTestForGCD getFuncPointer();

hwcTest.c
#include "hwcTest.h"
void realFunction(void *input){
	for(int i = 0;i < 5;i++){
		printf("%d\n",i);
		sleep(1);
	}
}
hwcTestForGCD getFuncPointer(){
	return realFunction;
}
ViewController.swift
class ViewController: UIViewController{  
    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))  
    override func viewDidLoad(){  
        super.viewDidLoad()  
      	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)
	dispatch_async_f(globalQueueDefault,nil,getFuncPointer())
	println("dispatch is over")
    }  
    override func didReceiveMemoryWarning(){  
        super.didReceiveMemoryWarning()  
    }  
} 
然后执行,会发现输出
0
dispatch is over
1
2
3
4

然后,我们同样改成dispatch_sync后执行,发现输出
0
1
2
3
4
5
dispatch is over
这里更能体会到了,什么是同步,什么是异步了吧。


三、理解下并行队列和串行队列
使用一或者二中的工程都可以,修改ViewController.swft中的代码就可以
这里用到了一个函数
func dispatch_queue_create(_ label: UnsafePointer<Int8>,
                         _ attr: dispatch_queue_attr_t!) -> dispatch_queue_t!
参数
label String类型的队列标示符,通常取做com.companyname.productname.functionname
attr   两种类型。DISPATCH_QUEUE_SERIAL创建一个顺序执行队列, DISPATCH_QUEUE_CONCURRENT创建同时执行队列


ViewController的完整代码,这里提交两个任务,通过输出来判断是并行队列,还是串行队列

class ViewController: UIViewController{  
    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))  
    override func viewDidLoad(){  
        super.viewDidLoad() 
	dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){
		for var i = 0;i < 5;i++ {
			NSLog("First task:%d",i)
			sleep(1)
		}
	}
	dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){
		for var j = 0;j < 5;j++ {
			NSLog("Second task:%d",j)
			sleep(1)
		}
	}
	println("dispatch is over")
    }  
    override func didReceiveMemoryWarning(){  
        super.didReceiveMemoryWarning()  
    }  
} 

这里执行输出为:

First task:0
Second task:0
First task:1
Second task:1
First task:2
Second task:2
First task:3
Second task:3
First task:4
Second task:4
这段代码执行时间4.03s


然后,我们使用串行执行的队列
class ViewController: UIViewController{  
    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))  
    override func viewDidLoad(){  
        super.viewDidLoad()
	var serialQueue =  dispatch_queue_create(label: 


"com.test.helloHwc",attr:DISPATCH_QUEUE_SERIAL)
	dispatch_async(serialQueue){
		for var i = 0;i < 5;i++ {
			NSLog("First task:%d",i)
			sleep(1)
		}
	}
	dispatch_async(serialQueue){
		for var j = 0;j < 5;j++ {
			NSLog("Second task:%d",j)
                        sleep(1)
		}
	}
	println("dispatch is over")
    }  
    override func didReceiveMemoryWarning(){  
        super.didReceiveMemoryWarning()  
    }  
} 

这里输出为

First task:0
First task:1
First task:2
First task:3
First task:4
Second task:0
Second task:1
Second task:2
Second task:3
Second task:4
这段代码执行时间8.06秒

看出来并行和串行执行的差别了吧。

所以,记住一点,把过程不相关的任务,提交到并行的队列中会显著提高效率

下一篇预计更新时间,本周末

BTY:如果图片下载失败,可能因为时间的原因,那张图片从服务器上删除了,自己找一个URL即可

原图



2018-03-28 16:15:44 jacob_ios 阅读数 10184
  • 2018年下半年上午真题20-25

    1.学会分布式集群架构的设计思想及部署策略 2.掌握项目中第三方接入技术的实战应用 3.掌握使用Nexus搭建Maven私服 4.掌握如何基于微服技术Spring boot升级电商爱旅行项目

    1807课时 0分钟 389人学习 任铄
    免费试看

Swift 2.x

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    let image = self.loadImage()
    // 回到主线程更新UI
    dispatch_async(dispatch_get_main_queue()) {
        self.imageView.image = image
    }
}
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(1.5 * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
    print("test")
}

Swift 4.0

DispatchQueue.global(qos: .userInitiated).async {
    let image = self.loadImage()
    // back to the main thread 
    DispatchQueue.main.async {
        self.imageView.image = image
    }
}
DispatchQueue.main.asyncAfter(deadline: .now() + 2.5) { 
    print("Are we there yet?")
}



2017-03-01 15:38:18 clarence20170301 阅读数 478
  • 2018年下半年上午真题20-25

    1.学会分布式集群架构的设计思想及部署策略 2.掌握项目中第三方接入技术的实战应用 3.掌握使用Nexus搭建Maven私服 4.掌握如何基于微服技术Spring boot升级电商爱旅行项目

    1807课时 0分钟 389人学习 任铄
    免费试看
 // Swift3.0将Foundation中的NS前缀去掉
    func parseJSONData() {
        // 1.config对象
        let sessionConfig: URLSessionConfiguration = URLSessionConfiguration.default
        // 自定义设置属性
        // 指定客户端接受的数据类型
        sessionConfig.httpAdditionalHeaders = ["Accept": "application/json"]
        // 设置请求/响应timeout(单位: 秒)
        sessionConfig.timeoutIntervalForRequest = 10.0
        sessionConfig.timeoutIntervalForResource = 20.0
        // 2.创建session
        let session = URLSession(configuration: sessionConfig)
        // 3.创建request
        let request = URLRequest(url: URL(string: "http://api.openweathermap.org/data/2.5/weather?q=Barcelona,es&appid=ac02dc102cc17b974cd84206048d97d8")!)
        // 4.创建dataTask任务
        let dataTask = session.dataTask(with: request) { (data, response, error) in
            // data, response, error都是可选型
            if let error = error {
                print("服务器返回失败: \(error.localizedDescription)")
            } else {
               // 没有错误
                if let data = data {
                    // dictionary是Any?
                    // 解包+转成字典类型
                    if let dictionary = try? JSONSerialization.jsonObject(with: data, options: JSONSerialization.ReadingOptions(rawValue: 0)) {
                        // dictionary是Any类型
                        let dic = (dictionary as? NSDictionary)!
                        // "name":"Barcelona",
                        let cityName = dic["name"] as! String
                        let temp = (dic["main"] as! NSDictionary)["temp"] as! Double
                        print("City name is \(cityName) and temp is \(temp)")
                        // 课堂练习:
                        
                        // 回到主线程: why?(主线程负责: 用户事件+UI Kit所有控件)
                        // Swift3.0对GCD的api更改
//                        DispatchQueue.main.async(execute: { 
//                            // 更新控件
//                        })
//                        dispatch_asyn(dispatch_get_main_queue, ^(){
//                            
//                            })
                        
                    }
             
                }
               
            }
        }
        // 5.执行任务
        dataTask.resume()
        
    }

2011-10-24 00:38:09 liuhongwei123888 阅读数 0
  • 2018年下半年上午真题20-25

    1.学会分布式集群架构的设计思想及部署策略 2.掌握项目中第三方接入技术的实战应用 3.掌握使用Nexus搭建Maven私服 4.掌握如何基于微服技术Spring boot升级电商爱旅行项目

    1807课时 0分钟 389人学习 任铄
    免费试看

     GCD全称为Grand Central Dispatch 在IOS4才开始,用来实现多线程。它是IOS多线程抽象层次最高的一层,下面还有更加轻量级的Cocoa operations,和Thread。

     当看到GCD的使用我仿佛看到了Android中的Handler和AsynTask。

在主线程中任意方法中加入:

     dispatch_async(dispatch_get_gloabal_queue(0, 0), ^{
		//加入耗时操作
		//......
		dispatch_async(dispatch_get_main_queue(), ^{
			//更新UI操作
			//.....
		});

    });
	
是否看到Android中Handler的影子? 首先需要在主线程中定义
	private Handler mHandler = new Handler();
	然后在子线程中使用
	mHandler.post(){
		public void run() {
			//更新UI操作
		}
	}
	
或者是:
	在主线程中:
	private Handler mHandler = new Handler() {
		public void handleMessage(Message msg) {
			switch(msg.what) {
				case 1:
					....
					break;
			}
		}
		
	};
	在子线程中:
	Message message =  new Message();
	message.what = 1;
	mHandler.sendMessage(message);


dispatch_async(dispatch_get_main_queue(), ^{.....});的作用是将代码块中的工作转回到主线程。

并发操作:有很多没有关联的耗时操作我们可以考虑使用并发操作。GCD提供实现并发操作的方法

	//因为不知是哪个线程先返回,故使用__block修饰变量来保存执行结果,确保在子线程中程序块内设置的值可供在以后得代码中使用。retain,是为了防止到程序最后变量已被释放,那就是白忙活了
	__block NSString *firstResult;
	__block NSString *secondResult;
	
	//分发线程执行操作
	dispatch_group_async(group, dispatch_get_gloabal_queue(0, 0), ^{
		firstResult = [[ ...] retain];
	});
	
	//分发线程执行操作
	dispatch_group_async(group, dispatch_get_gloabal_queue(0, 0), ^{
		secondResult = [[ ...] retain];
	});
	
	//该程序块在组中所有程序块即将执行完时执行
	dispatch_group_notify(group, dispatch_get_gloabal_queue(0, 0), ^{
		//....
		dispatch_async(dispatch_get_main_queue(), ^{
			//更新UI操作
			//.....
		});
	});

在上面的代码中是否看到了Android中AsyncTask的影子?

    doInBackground(...){...}

    onPostExecute(....){...}

GCD

阅读数 0