funcexdispathQueue(){//自定义的dispatchQueue
letserialQ =dispatch_queue_create("selrialQueue",DISPATCH_QUEUE_SERIAL)//串行队列程序的主线程就是一个串行的队列。在系统级别的多线程称之为多进程
letconcurrentQ =dispatch_queue_create("conQueue",DISPATCH_QUEUE_CONCURRENT)//并行队列
//区别串行队列中的线程是串行的，要实现多线程的话，则需要创建多个串行队列，当线程较多时，内存消耗的厉害；并行队列，队列中的线程，比如线程1，和线程2，先执行1的一部分，马上执行2的一部分，这样就实现了一个并行队列的多线程。通常，程序里面的多线程都是并行队列来实现的
}
classfuncsystemQueue(){//系统提供的标准队列
//main dispatch queue主线程串行队列
letmainQ =dispatch_get_main_queue()//获取主队列
//Global Dispatch Queue不需要通过dispatch_queue_create函数来逐个生成Concurrent Dispatch Queue，只要获取Global Dispatch Queue就行了
letGlobalQ =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)
//使用示例
dispatch_async(GlobalQ) {
print(NSThread.currentThread())
vara:String?
a ="线程变量"
//做一些耗时操作完成之后返回主线程
dispatch_async(dispatch_get_main_queue(), {
print(NSThread.currentThread())
print(a)
})
}
}
classfuncdispatchGroupOne(){//虽然也是group，但是有个问题，如果子线程中有异步的，就有问题，所以如果子线程中有下载或上传等异步任务，这种group就不行
letqueue =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)//创建并行队列
letgroup =dispatch_group_create()//创建组
dispatch_group_async(group, queue) {print("任务1")}
dispatch_group_async(group, queue) {print("任务2")}//向线程组里添加线程任务
dispatch_group_async(group, queue) {print("任务3")}
//dispatch_group_notify(group, dispatch_get_main_queue()) {
//print("1,2,3都完成了")//所有任务都完成了再执行某一任务。
//}
letresult =dispatch_group_wait(group,DISPATCH_TIME_FOREVER)//------>这个是上面的翻版，意思是如果group里面的线程没结束就永远等待下去，等的结果通过返回值表现
ifresult ==0{//返回0表示全结束了，看API
print("1,2,3都完成了")
}
}
classfuncdispatchGroupTwo(){//这种方案应对线程之中如果有异步操作，比如发表说说
letgroup =dispatch_group_create()
foriin0...3{
dispatch_group_enter(group)
letqueue =dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)
dispatch_async(queue, {
//耗时操作完成之后
print(i)
dispatch_group_leave(group)
})
}
dispatch_group_notify(group,dispatch_get_main_queue()) {
print("都完成了")
}
}
classfuncapply() -> () {//将第三个参数block加入到第二个参数的队列中去。第一个参数是执行这样的操作的次数
dispatch_apply(10,dispatch_get_global_queue(QOS_CLASS_DEFAULT,0)) { (index)in
print(index)
}
}
funcsuspendQ() -> () {//对加入队列中未执行的block暂停或继续其执行
//dispatch_suspend(queue)暂停
//dispatch_resume(queue)恢复
}
classfuncdispatchSet() ->() {
//let queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
//let queue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
//
//dispatch_set_target_queue(queue1, queue2)//将queue1的优先级设置为queue2的优先级一致设置队列的优先级
//
//dispatch_apply(1, queue1) { (index) in
//print("queue1----\(NSThread.currentThread())")
//}
//
//dispatch_apply(1, queue2) { (index) in
//print("queue2----\(NSThread.currentThread())")
//}
lettargetQueue =dispatch_queue_create("targetQueue",DISPATCH_QUEUE_SERIAL)
letqueue1 =dispatch_queue_create("queue1",DISPATCH_QUEUE_CONCURRENT)
letqueue2 =dispatch_queue_create("queue2",DISPATCH_QUEUE_CONCURRENT)
//targetQueue是串行队列，如果希望queue1与queue2同步执行，则dispatch_set_target_queue将排上用场，不这么处理，q1与q2将并行处理
dispatch_set_target_queue(queue1, targetQueue)
dispatch_set_target_queue(queue2, targetQueue)
dispatch_async(queue1) {
foriin0...5{
NSThread.sleepForTimeInterval(0.5)
print("queue1----\(NSThread.currentThread()) ----\(i)")
}
}
dispatch_async(queue1) {
foriin0...5{
NSThread.sleepForTimeInterval(0.5)
print("queue1 again----\(NSThread.currentThread()) ----\(i)")
}
}
dispatch_async(queue2){
foriin0...5{
NSThread.sleepForTimeInterval(0.5)
print("queue2----\(NSThread.currentThread()) ----\(i)")
}
}
}
classfuncbarrier() {//作用异步线程barrier前面的线程执行结束,再继续执行后面的代码1.实现高效率的数据库访问和文件访问2.避免数据竞争q1,q2次序不定，q3,q4次序不定。但是肯定是q1,q2执行完后才执行q3,q4
letqueue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT)
dispatch_async(queue) {
print("----1\(NSThread.currentThread())")
}
dispatch_async(queue) {
print("----2\(NSThread.currentThread())")
NSThread.sleepForTimeInterval(5)
}
dispatch_barrier_async(queue) {
print("5s delay continue running")
}
dispatch_async(queue) {
print("----3\(NSThread.currentThread())")
}
dispatch_async(queue) {
print("----4\(NSThread.currentThread())")
}
}
classfuncSemaphore() -> () {
letgroupQ =dispatch_group_create()
letsemQueue =dispatch_semaphore_create(10)//创建信号量为10的信号队列
lettaskQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)
foriin0...20{
dispatch_semaphore_wait(semQueue,DISPATCH_TIME_FOREVER)//信号量-1如果总信号量为0则永远等待下去
dispatch_group_async(groupQ, taskQueue, {
print("-----\(i)")
NSThread.sleepForTimeInterval(5)
dispatch_semaphore_signal(semQueue)//信号量+1
})
}
dispatch_group_notify(groupQ,dispatch_get_main_queue()) {
print("我执行完了")
}//运行这段代码可以发现，使用信号量配合group可以实现同一时刻异步执行的线程的个数，从而实现并发控制，原理是主线程每循环10次,信号量就为0主线程进入等待。开辟了10个子线程之后，每个子线程都被阻塞5s，阻塞完成后，每个子线程又各自将信号量+1这样信号总量又为10，从而进入下一个循环。由于cup运算速度极快，每一组子线程之间的先后次序可以认为是同一时刻。这样就实现了并发控制
}
