宁梓茞
宁梓茞

iOS多线程技术方案

目录

一、多线程简介

1、多线程的由来
2、耗时操作的模拟试验
3、进程和线程
4、多线程的概念及原理
5、多线程的优缺点和一个Tip
6、主线程
7、技术方案

二、Pthread

1、函数
2、参数和返回值
3、使用

三、NSThread

1、创建一个新的线程
2、线程的状态
3、线程的属性

四、互斥锁

1、访问共享资源引入问题！
2、互斥锁介绍
3、互斥锁原理
4、互斥锁和自旋锁

五、GCD

1、GCD介绍
3、函数
4、串行队列和并发队列
5、主队列
6、全局队列
7、GCD总结

六、NSOperation

1、NSOperation简介
2、核心概念
3、操作步骤
4、NSInvocationOperation
5、NSBlockOperation

七、案例

一、多线程简介

1、多线程的由来

一个进程（进程）在执行一个线程（线程中有很多函数或方法（后面简称Function））的时候，其中有一个Function执行的时候需要消耗一些时间，但是这个线程又必须同时执行这个Function之后的Function，问题来了，一个线程中的任何一个Function都必须等待其执行完成后才能执行后面的Function，如果要同时执行两个或者多个Function，那么，就必须多开一个或者多个线程，这就是多线程的产生。我想多线程最开始的诞生就是由这而来吧！

2、耗时操作的模拟试验

2.1 循环测试

代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
    NSLog(@"bengin");
    for (int i = 0; i < 10000000; i++) {
    }
    NSLog(@"end");
}
return 0;
}

控制台

2016-02-16 13:51:54.140 Test[1670:603696] bengin
2016-02-16 13:51:54.160 Test[1670:603696] end
Program ended with exit code: 0

结论一：循环一亿次耗时0.02秒，计算机的运行速度是非常快的

2.2 操作栈区

代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
    NSLog(@"bengin");
    for (int i = 0; i < 10000000; i++) {
        int n = 1;
    }
    NSLog(@"end");
}
return 0;
}

控制台

2016-02-16 13:57:37.589 Test[1734:631377] bengin
2016-02-16 13:57:37.612 Test[1734:631377] end
Program ended with exit code: 0

结论二：对栈区操作一亿次，耗时0.023秒

2.3 操作常量区

代码：

int main(int argc, const char * argv[]) {
@autoreleasepool {
    NSLog(@"bengin");
    for (int i = 0; i < 10000000; i++) {
        NSString *str = @"hellow";
    }
    NSLog(@"end");
}
return 0;
}

控制台

2016-02-16 14:03:59.003 Test[1763:659287] bengin
2016-02-16 14:03:59.113 Test[1763:659287] end
Program ended with exit code: 0

结论三：对常量区操作一亿次，耗时0.11秒

2.4 操作堆区

代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
    NSLog(@"bengin");
    for (int i = 0; i < 10000000; i++) {
        NSString *str = [NSString stringWithFormat:@"%d",I];
    }
    NSLog(@"end");
}
return 0;
}

控制台

2016-02-16 14:09:03.673 Test[1786:673719] bengin
2016-02-16 14:09:10.705 Test[1786:673719] end
Program ended with exit code: 0

结论四：对堆区操作一亿次耗时7秒多一些，较慢！
2.5 I/O操作

代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
    NSLog(@"bengin");
    for (int i = 0; i < 10000000; i++) {
        NSLog(@"%d",i);
    }
    NSLog(@"end");
}
return 0;
}

控制台输出！正在跑中，一亿次！！！先看截图
CPU

iOS多线程技术方案_第1张图片
842039-20161007133601457-818678442-2.jpg

再看内存
iOS多线程技术方案_第2张图片
842039-20161007133617879-1858425672.jpg

好吧，还在跑，现在已经达到10分钟了，怕心疼本本炸掉！stop。。。
结论五：I/O操作非常慢，一亿次10分钟也没能跑完！

最终结论：通过以上结论一、二、三、四、五得出一个结论，各个区的执行效率：栈区>常量区>堆区>I/O操作。同时也说明了一个问题，执行不同的方法会产什么耗时操作。这是，为了解决耗时操作问题，多线程闪亮诞生！

3、进程和线程

先说说进程和线程吧！

3.1 进程

3.1.1 进程的概念：系统中正在运行的应用程序。

3.1.2 进程的特点：每个进程都运行在其专用且受保护的内存空间，不同的进程之间相互独立，互不干扰。

3.2 线程

3.2.1 线程的概念：线程是进程的执行任务的基本单元，一个进程的所有任务都是在线程中执行的。（每一个进程至少要有一条线程）。

3.2.2 线程的特点：线程在执行任务的时候是按顺序执行的。如果要让一条线程执行多个任务，那么只能一个一个地并且按顺序执行这些任务。也就是说，在同一时间，一条线程只能执行一个任务。

我们可以通过Mac中的活动监视器查看进程和线程，下图！


iOS多线程技术方案_第3张图片
842039-20161007133638785-2012708993.jpg

4、多线程的概念及原理
4.1 多线程概念：1个进程可以开启多条线程，多条线程可以同时执行不同的任务。

4.2 多线程原理：


iOS多线程技术方案_第4张图片
842039-20161007133647817-1360768741.jpg

前提是在单核CPU的情况下，同一时间，CPU只能处理一条线程，也就是说只有一条线程在执行任务。多线程同时执行，那是不可能的！但是是CPU快速地在多条线程之间进行调度和切换执行任务。如果CPU调度线程的速度足够快，就会造成多条线程同时执行任务的”假象”，这种假象，就被美誉为：多线程!

5、多线程的优缺点和一个Tip

5.1 多线程的优点

  • 可以适当提高程序的执行效率

  • 也可以适当提高资源的利用率(CPU、内存利用率)

    5.2 多线程的缺点

  • 开启一条线程需要占用一定的内存空间（默认情况下，每一条线程都占用512KB），如果开启大量的线程，会占用大量的内存空间，从而降低程序的性能。

  • 线程越多，CPU在调度和切换线程上的开销就会越大。

  • 线程数越多，程序的设计会越复杂。

    5.3 Tip

  • 开启新的线程就会消耗资源，但是却可以提高用户体验。在保证良好的用户体验的前提下，可以适当地开线程，一般开3-6条。

    iOS多线程技术方案_第5张图片
    842039-20161007133703785-321985059.jpg

    开启一条新的线程，默认情况下，一条线程都是占用512KB，但是官方的文档里面给出的说明却不是，为了得出真相，下面做个小小的测试！
    代码

int main(int argc, const char * argv[]) {
@autoreleasepool {
/** 操作主线程 /
NSLog(@"主线程默认 %tu", [NSThread currentThread].stackSize / 1024);
// 设置主线程的stackSize
[NSThread currentThread].stackSize = 1024 1024;
NSLog(@"主线程修改 %tu", [NSThread currentThread].stackSize / 1024);

/** 操作子线程 */
NSThread *thread = [[NSThread alloc] init];
NSLog(@"thread默认 %tu", thread.stackSize / 1024);
// 设置子线程的stackSize
thread.stackSize = 8 * 1024;
NSLog(@"thread修改 %tu", thread.stackSize / 1024);
[thread start];
}
return 0;
}

控制台

2016-02-17 08:36:02.652 Test[609:110129] 主线程默认 512
2016-02-17 08:36:02.654 Test[609:110129] 主线程修改 1024
2016-02-17 08:36:02.654 Test[609:110129] thread默认 512
2016-02-17 08:36:02.654 Test[609:110129] thread修改 8

结论七：证明了，不管什么线程，默认都是512，最小为8.可能是官方文档没有及时更新吧！

6、主线程

6.1 主线程的概念：

一个应用程序在启动运行后，系统会自动开启1条线程，这条称为”主线程”。

6.2 主线程的作用：主线程的作用主要用于处理UI界面刷新和UI时间！

6.3 结论：主线程上不能执行耗时操作，这样会造成界面卡顿，给用户一种不好的体验。

7、技术方案

iOS多线程技术方案_第6张图片
842039-20161007133715301-1657998062.jpg

二、Pthread

1、函数

pthread_create(pthread_t *restrict, const pthread_attr_t *restrict, void *(*)(void *), void *restrict)

2、参数和返回值

  • pthread_t *restrict 线程编号的地址

  • const pthread_attr_t *restrict 线程的属性

  • void ()(void ) 线程要执行的函数void * () (void *)

    • int * 指向int类型的指针 void * 指向任何类型的指针 有点类似OC中的id

  • void *restrict 要执行的函数的参数

  • 返回值 int类型 0是成功 非0 是失败

3、使用

代码

#import 
#import 

void *demo(void *param) {
NSString *name = (__bridge NSString *)(param);

NSLog(@"hello %@ %@",name,[NSThread currentThread]);
return NULL;
}

int main(int argc, const char * argv[]) {
@autoreleasepool {
    //创建子线程
    pthread_t pthread; //线程编号
    
    NSString *test = @"test";
    int result =  pthread_create(&pthread, NULL, demo, (__bridge void *)(test));
    NSLog(@"Began  %@",[NSThread currentThread]);
    
    if (result == 0) {
        NSLog(@"成功");
    }else {
        NSLog(@"失败");
    }
}
return 0;
}

控制台

2016-02-16 22:00:57.401 Test[888:42585] Began  {number = 1, name = main}
2016-02-16 22:00:57.403 Test[888:42615] hello test {number = 2, name = (null)}
2016-02-16 22:00:57.403 Test[888:42585] 成功

  • __bridge 桥接，把OC中的对象，传递给c语言的函数，使用__bridge

    三、NSThread

    1、创建一个新的线程

  • 方式一

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

方式二

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

方式三

[self performSelectorInBackground:@selector(demo) withObject:nil];

2、线程的状态

线程状态分为五种

  • 创建 New
  • 就绪 Runnable
  • 运行 Running
- (void)start;
  • 阻塞（暂停） Blocked
+ (void)sleepUntilDate:(NSDate *)date; + (void)sleepForTimeInterval:(NSTimeInterval)ti;
  • 死亡 Dead
+ (void)exit;

3、线程的属性

3、线程的属性
线程有两个重要的属性：名称和优先级

3.1 名称 name

设置线程名用于记录线程，在出现异常时可以DeBug

3.2 优先级，也叫做“服务质量”。threadPriority，取值0到1.

优先级或者服务质量高的，可以优先调用，只是说会优先调用，但是不是百分之百的优先调用，这里存在一个概率问题，内核里的算法调度线程的时候，只是把优先级作为一个考虑因素，还有很多个因数会决定哪个线程优先调用。这点得注意注意！！！

下面是测试代码

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
//新建状态
NSThread *test1 = [[NSThread alloc] initWithTarget:self selector:@selector(demo) object:nil];
test1.name = @"test1";
//线程的优先级
test1.threadPriority = 1.0;
//就绪状态
[test1 start];


//新建状态
NSThread *test2= [[NSThread alloc] initWithTarget:self selector:@selector(demo) object:nil];
test2.name = @"test2";
test2.threadPriority = 0;
//就绪状态
[test2 start];
}

//线程执行完成之后会自动销毁
- (void)demo {
for (int i = 0; i < 20; i++) {
    NSLog(@"%d--%@",i,[NSThread currentThread]);
}
}

控制台

2016-02-16 22:43:28.182 05-线程状态[1241:78688] 0--{number = 2, name = test1}
2016-02-16 22:43:28.182 05-线程状态[1241:78689] 0--{number = 3, name = test2}
2016-02-16 22:43:28.182 05-线程状态[1241:78688] 1--{number = 2, name = test1}
2016-02-16 22:43:28.182 05-线程状态[1241:78688] 2--{number = 2, name = test1}
2016-02-16 22:43:28.182 05-线程状态[1241:78689] 1--{number = 3, name = test2}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 3--{number = 2, name = test1}
2016-02-16 22:43:28.183 05-线程状态[1241:78689] 2--{number = 3, name = test2}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 4--{number = 2, name = test1}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 5--{number = 2, name = test1}
2016-02-16 22:43:28.183 05-线程状态[1241:78689] 3--{number = 3, name = test2}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 6--{number = 2, name = test1}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 7--{number = 2, name = test1}
2016-02-16 22:43:28.183 05-线程状态[1241:78689] 4--{number = 3, name = test2}
2016-02-16 22:43:28.183 05-线程状态[1241:78688] 8--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 9--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 10--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78689] 5--{number = 3, name = test2}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 11--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78689] 6--{number = 3, name = test2}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 12--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 13--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78689] 7--{number = 3, name = test2}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 14--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78688] 15--{number = 2, name = test1}
2016-02-16 22:43:28.185 05-线程状态[1241:78688] 16--{number = 2, name = test1}
2016-02-16 22:43:28.184 05-线程状态[1241:78689] 8--{number = 3, name = test2}
2016-02-16 22:43:28.185 05-线程状态[1241:78688] 17--{number = 2, name = test1}
2016-02-16 22:43:28.185 05-线程状态[1241:78688] 18--{number = 2, name = test1}
2016-02-16 22:43:28.185 05-线程状态[1241:78689] 9--{number = 3, name = test2}
2016-02-16 22:43:28.185 05-线程状态[1241:78688] 19--{number = 2, name = test1}
2016-02-16 22:43:28.185 05-线程状态[1241:78689] 10--{number = 3, name = test2}
2016-02-16 22:43:28.186 05-线程状态[1241:78689] 11--{number = 3, name = test2}
2016-02-16 22:43:28.186 05-线程状态[1241:78689] 12--{number = 3, name = test2}
2016-02-16 22:43:28.186 05-线程状态[1241:78689] 13--{number = 3, name = test2}
2016-02-16 22:43:28.186 05-线程状态[1241:78689] 14--{number = 3, name = test2}
2016-02-16 22:43:28.187 05-线程状态[1241:78689] 15--{number = 3, name = test2}
2016-02-16 22:43:28.187 05-线程状态[1241:78689] 16--{number = 3, name = test2}
2016-02-16 22:43:28.187 05-线程状态[1241:78689] 17--{number = 3, name = test2}
2016-02-16 22:43:28.187 05-线程状态[1241:78689] 18--{number = 3, name = test2}
2016-02-16 22:43:28.187 05-线程状态[1241:78689] 19--{number = 3, name = test2}

结论六：优先级高，不一定先执行，只能说明先执行的概率要大一些！！！

四、互斥锁

1、访问共享资源引入问题！

1.1 问题？

不同的线程要访问共享的资源，而且对共享的资源做操作，由于上面结论六得出服务质量和优先级不能决定线程执行的先后顺序，那么问题来了，一个线程对共享资源做了修改，而另外一个线程拿到的是未被修改之前资源，这是这个线程也对该资源做了修改，现在请问，两个线程都对该资源做了不同的修改，那么这个修改应该算谁的？！？！这就是问题所在！！！

1.2 问题分析

iOS多线程技术方案_第7张图片
842039-20161007133732707-1697195684.jpg

1.3 问题解决
iOS多线程技术方案_第8张图片
842039-20161007133742864-1914164839.jpg

这个文档里盗的图！

解决方案很简单，就是用一把锁锁住共享资源，等待线程1对其操作完毕后再打开，让线程2来执行，这就是传说中的互斥锁！！！

2、互斥锁介绍

2.1 互斥锁代码

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

2.2 互斥锁的作用

可以防止因多线程执行顺序不定导致的抢夺资源造成的数据安全的问题

2.3 真相：互斥锁其实就是同步的意思，也就是按顺序执行！

3、互斥锁原理

每个NSObject对象内部都有一把锁，当线程要进入synchronized到对象的时候就要判断，锁是否被打开，如果打开，进入执行，如果锁住，继续等待，这就是互斥锁的原理！

4、互斥锁和自旋锁

自旋锁就是atomic！

4.1 原子属性和非原子属性（nonatomic 和 atomic）

  • nonatomic:非原子属性，不会为 setter 方法加锁。
  • atomic: 原子属性，为 setter 方法加锁(默认就是atomic)。
    • 通过给 setter 加锁，可以保证同一时间只有一个线程能够执行写入操作(setter)，但是同一时间允许多个线程执行读取操作(getter)。atomic本身就有一把自旋锁。
      这个特点叫做”单写多读”: 单个线程写入，多个线程读取。
    • atomic 只能保证写入数据的时候是安全的，但不能保证同时读写的时候是安全的。所以，不常使用！

4.2 nonatomic 和 atomic 的对比

atomic：线程安全(执行setter方法的时候)，需要消耗大量的资源。

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

4.3 互斥锁和自旋锁的区别

互斥锁

如果发现其它线程正在执行锁定代码，线程会进入休眠(阻塞状态)，等其它线程时间片到了打开锁后，线程就会被唤醒(执行)。

自旋锁

如果发现有其它线程正在执行锁定代码，线程会以死循环的方式，一直等待锁定的代码执行完成。

五、GCD

1、GCD介绍

全称Grand Central Dispatch,可翻译为”牛逼的中枢调度器”

纯C语言开发，是苹果公司为多核的并行运算提出的解决方案，会自动利用更多的CPU内核（比如双核、四核），可以自动管理线程的生命周期（创建线程、调度任务、销毁线程）。

2、GCD的两个核心

2.1 任务

  • 执行的操作,在GCD中，任务是通过 block来封装的。并且任务的block没有参数也没有返回值。

2.2 队列

  • 存放任务

包括

  • 串行队列
  • 并发队列
  • 主队列
  • 全局队列

队列的类型


iOS多线程技术方案_第9张图片
842039-20161007133804582-780353398.jpg

3、函数
3.1 GCD函数

3.1.1 同步 dispatch_sync

同步：任务会在当前线程执行，因为同步函数不具备开新线程的能力。


void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

3.1.2 异步 dispatch_async

异步：任务会在子线程执行，因为异步函数具备开新线程的能力。

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

3.2 GCD使用步骤:

创建队列，或则获取队列
创建任务
将任务添加到队列中
GCD会自动将队列中的任务取出，放到对应的线程中执行
任务取出遵循队列的FIFO原则：先进先出，后进后出
示例代码

// 1. 获取全局队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 2. 创建任务
dispatch_block_t task = ^ {
    NSLog(@"hello %@", [NSThread currentThread]);
};
// 3. 将任务添加到队列，并且指定执行任务的函数
dispatch_async(queue, task);

通常写成一句代码

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"hello %@", [NSThread currentThread]);
    });

4、串行队列和并发队列
4.1 串行队列 (Serial Dispatch Queue)

4.1.1 特点

先进先出，按照顺序执行,并且一次只能调用一个任务
无论队列中所指定的执行任务的函数是同步还是异步，都必须等待前一个任务执行完毕才可以调用后面的人
4.1.2 创建一个串行队列

方法一

dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);

方法二

dispatch_queue_t queue = dispatch_queue_create("test", NULL);

4.1.3 串行队列，同步执行

代码：

// 1、创建串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 2、将任务添加到队列，并且指定同步执行
for (int i = 0; i < 10; i++) {
    dispatch_sync(queue, ^{
        NSLog(@"%@--%d",[NSThread currentThread],i);
    });
}

打印结果：

2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--0
2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--1
2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--2
2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--3
2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--4
2016-02-25 16:31:07.849 test[1924:376468] {number = 1, name = main}--5
2016-02-25 16:31:07.850 test[1924:376468] {number = 1, name = main}--6
2016-02-25 16:31:07.850 test[1924:376468] {number = 1, name = main}--7
2016-02-25 16:31:07.850 test[1924:376468] {number = 1, name = main}--8
2016-02-25 16:31:07.850 test[1924:376468] {number = 1, name = main}--9

结论：串行队列，同步执行，不开新线程，按顺序执行

4.1.4 串行队列，异步执行

代码：

// 1、创建串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 2、将任务添加到队列，并且指定同步执行
for (int i = 0; i < 10; i++) {
    dispatch_async(queue, ^{
        NSLog(@"%@--%d",[NSThread currentThread],i);
    });
}

打印结果：

2016-02-25 17:08:32.167 test[1959:391722] {number = 2, name = (null)}--0
2016-02-25 17:08:32.168 test[1959:391722] {number = 2, name = (null)}--1
2016-02-25 17:08:32.168 test[1959:391722] {number = 2, name = (null)}--2
2016-02-25 17:08:32.168 test[1959:391722] {number = 2, name = (null)}--3
2016-02-25 17:08:32.168 test[1959:391722] {number = 2, name = (null)}--4
2016-02-25 17:08:32.168 test[1959:391722] {number = 2, name = (null)}--5
2016-02-25 17:08:32.169 test[1959:391722] {number = 2, name = (null)}--6
2016-02-25 17:08:32.169 test[1959:391722] {number = 2, name = (null)}--7
2016-02-25 17:08:32.169 test[1959:391722] {number = 2, name = (null)}--8
2016-02-25 17:08:32.169 test[1959:391722] {number = 2, name = (null)}--9

结论：串行队列，异步执行，开启一条新的线程，按顺序执行

4.2 并发队列 (Concurrent Dispatch Queue)

4.2.1 特点

并发同时调度队列中的任务去执行
如果当前调度的任务是同步执行的，会等待当前任务执行完毕后，再调度后续的任务
如果当前调度的任务是异步执行的，同时底层线程池有可用的线程资源，就不会等待当前任务，直接调度任务到新线程去执行。
4.2.2 创建并发队列

dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

4.2.3 并发队列，同步执行

代码：

// 1. 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 2. 将任务添加到队列, 并且指定同步执行
for (int i = 0; i < 10; i++) {
    dispatch_sync(queue, ^{
        NSLog(@"%@ %d", [NSThread currentThread], i);
    });
}

输出：

2016-02-25 17:18:38.039 test[1979:399667] {number = 1, name = main} 0
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 1
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 2
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 3
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 4
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 5
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 6
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 7
2016-02-25 17:18:38.040 test[1979:399667] {number = 1, name = main} 8
2016-02-25 17:18:38.041 test[1979:399667] {number = 1, name = main} 9

结论:并发队列，同步执行，不开线程，顺序执行

4.2.4 并发队列，异步执行

代码：

// 1. 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 2. 将任务添加到队列, 并且指定同步执行
for (int i = 0; i < 10; i++) {
    dispatch_async(queue, ^{
        NSLog(@"%@ %d", [NSThread currentThread], i);
    });
}

输出：

2016-02-25 17:22:59.357 test[1992:403694] {number = 7, name = (null)} 6
2016-02-25 17:22:59.356 test[1992:403684] {number = 3, name = (null)} 1
2016-02-25 17:22:59.356 test[1992:403689] {number = 5, name = (null)} 3
2016-02-25 17:22:59.356 test[1992:403683] {number = 2, name = (null)} 0
2016-02-25 17:22:59.356 test[1992:403692] {number = 6, name = (null)} 4
2016-02-25 17:22:59.356 test[1992:403693] {number = 8, name = (null)} 5
2016-02-25 17:22:59.356 test[1992:403695] {number = 9, name = (null)} 7
2016-02-25 17:22:59.357 test[1992:403688] {number = 4, name = (null)} 2
2016-02-25 17:22:59.357 test[1992:403694] {number = 7, name = (null)} 9
2016-02-25 17:22:59.357 test[1992:403696] {number = 10, name = (null)} 8

结论：开启足够多的线程，不按照顺序执行
CPU在调度的时候以最高效的方式调度和执行任务，所以会开启多条线程，因为并发，执行顺序不一定

5、主队列

5.1 主队列

主队列是系统提供的，无需自己创建，可以通过dispatch_get_main_queue()函数来获取。

5.2 特点

  • 添加到主队列的任务只能由主线程来执行。

  • 先进先出的，只有当主线程的代码执行完毕后，主队列才会调度任务到主线程执行

    5.3 主队列 异步执行

    代码

// 1. 获取主队列
dispatch_queue_t q = dispatch_get_main_queue();
// 2. 将任务添加到主队列, 并且指定异步执行
for (int i = 0; i < 10; i++) {
dispatch_async(q, ^{
    NSLog(@"%@ %d", [NSThread currentThread], i);
});
}
// 先执行完这句代码, 才会执行主队列中的任务
NSLog(@"hello %@", [NSThread currentThread]);

打印

2016-02-25 21:10:43.293 test[773:786816] hello {number = 1, name = main}
2016-02-25 21:10:43.295 test[773:786816] {number = 1, name = main} 0
2016-02-25 21:10:43.295 test[773:786816] {number = 1, name = main} 1
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 2
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 3
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 4
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 5
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 6
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 7
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 8
2016-02-25 21:10:43.296 test[773:786816] {number = 1, name = main} 9

打印结果得出的一些结论

在主线程顺序执行，不开启新的线程
主队列的特点：只有当主线程空闲时，主队列才会调度任务到主线程执行
主队列就算是异步执行也不会开启新的线程
主队列相当于一个全局的串行队列
主队列和串行队列的区别
串行队列:必须等待一个任务执行完毕，才会调度下一个任务。
主队列:如果主线程上有代码执行，主队列就不调度任务。
5.4 主队列 同步执行（死锁）

代码

NSLog(@"begin");
// 1. 获取主队列
dispatch_queue_t q = dispatch_get_main_queue();
// 2. 将任务添加到主队列, 并且指定同步执行
// 死锁
for (int i = 0; i < 10; i++) {
    dispatch_sync(q, ^{
        NSLog(@"%@ %d", [NSThread currentThread], i);
    });
}
NSLog(@"end");

打印

2016-02-25 21:19:25.986 test[791:790967] begin

打印结果可以看出，不是想要的结果，这时候发生了死锁
在主线程执行，主队列同步执行任务，会发生死锁，主线程和主队列同步任务相互等待，造成死锁

解决办法

代码

NSLog(@"begin");
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    NSLog(@"--- %@", [NSThread currentThread]);
    // 1. 获取主队列
    dispatch_queue_t q = dispatch_get_main_queue();
    // 2. 将任务添加到主队列, 并且指定同步执行
    // 死锁
    for (int i = 0; i < 10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
});
NSLog(@"end");

打印

2016-02-25 21:23:23.205 test[803:794826] begin
2016-02-25 21:23:23.206 test[803:794826] end
2016-02-25 21:23:23.206 test[803:794866] --- {number = 2, name = (null)}
2016-02-25 21:23:23.209 test[803:794826] {number = 1, name = main} 0
2016-02-25 21:23:23.209 test[803:794826] {number = 1, name = main} 1
2016-02-25 21:23:23.209 test[803:794826] {number = 1, name = main} 2
2016-02-25 21:23:23.209 test[803:794826] {number = 1, name = main} 3
2016-02-25 21:23:23.209 test[803:794826] {number = 1, name = main} 4
2016-02-25 21:23:23.210 test[803:794826] {number = 1, name = main} 5
2016-02-25 21:23:23.210 test[803:794826] {number = 1, name = main} 6
2016-02-25 21:23:23.210 test[803:794826] {number = 1, name = main} 7
2016-02-25 21:23:23.210 test[803:794826] {number = 1, name = main} 8
2016-02-25 21:23:23.210 test[803:794826] {number = 1, name = main} 9

打印结果可以看出，当我们将主队列同步执行任务放到子线程去执行，就不会出现死锁。由于将主队列同步放到了子线程中执行，主队列同步任务无法阻塞主线程执行代码，因此主线程可以将主线程上的代码执行完毕。当主线程执行完毕之后，就会执行主队列里面的任务。

6、全局队列

全局队列是系统提供的，无需自己创建，可以直接通过dispatch_get_global_queue(long identifier, unsigned long flags);函数来获取。

6.1 全局队列 异步执行

代码

// 1. 获取全局队列
dispatch_queue_t q = dispatch_get_global_queue(0, 0);
// 2. 将任务添加到全局队列, 异步执行
for (int i = 0; i < 10; i++) {
    dispatch_async(q, ^{
        NSLog(@"%d %@", i, [NSThread currentThread]);
    });
}

打印输出

2016-02-25 21:29:06.978 test[816:799523] 1 {number = 3, name = (null)}
2016-02-25 21:29:06.978 test[816:799530] 4 {number = 6, name = (null)}
2016-02-25 21:29:06.978 test[816:799522] 0 {number = 2, name = (null)}
2016-02-25 21:29:06.978 test[816:799529] 3 {number = 5, name = (null)}
2016-02-25 21:29:06.978 test[816:799532] 6 {number = 7, name = (null)}
2016-02-25 21:29:06.978 test[816:799533] 7 {number = 8, name = (null)}
2016-02-25 21:29:06.978 test[816:799531] 5 {number = 9, name = (null)}
2016-02-25 21:29:06.978 test[816:799526] 2 {number = 4, name = (null)}
2016-02-25 21:29:06.979 test[816:799534] 8 {number = 10, name = (null)}
2016-02-25 21:29:06.979 test[816:799523] 9 {number = 3, name = (null)}

特点：

1、全局队列的工作特性跟并发队列一致。 实际上，全局队列就是系统为了方便程序员，专门提供的一种特殊的并发队列。

2、全局队列和并发队列的区别：

  • 全局队列没有名称，无论ARC还是MRC都不需要考虑内存释放，日常开发，建议使用全局队列
  • 并发队列有名称，如果在MRC开发中，需要使用dispatch_release来释放相应的对象，dispatch_barrier 必须使用自定义的并发队列，开发第三方框架，建议使用并发队列
    3、函数
dispatch_get_global_queue(long identifier, unsigned long flags);

这个函数中有两个参数:
第一个参数: identifier
iOS7.0，表示的是优先级:
DISPATCH_QUEUE_PRIORITY_HIGH = 2; 高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT = 0; 默认优先级
DISPATCH_QUEUE_PRIORITY_LOW = -2; 低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND = INT16_MIN; 后台优先级
iOS8.0开始，推荐使用服务质量(QOS):
QOS_CLASS_USER_INTERACTIVE = 0x21; 用户交互
QOS_CLASS_USER_INITIATED = 0x19; 用户期望
QOS_CLASS_DEFAULT = 0x15; 默认
QOS_CLASS_UTILITY = 0x11; 实用工具
QOS_CLASS_BACKGROUND = 0x09; 后台
QOS_CLASS_UNSPECIFIED = 0x00; 未指定
通过对比可知: 第一个参数传入0，可以同时适配iOS7及iOS7以后的版本。
服务质量和优先级是一一对应的:
DISPATCH_QUEUE_PRIORITY_HIGH: QOS_CLASS_USER_INITIATED
DISPATCH_QUEUE_PRIORITY_DEFAULT: QOS_CLASS_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW: QOS_CLASS_UTILITY
DISPATCH_QUEUE_PRIORITY_BACKGROUND: QOS_CLASS_BACKGROUND
第二个参数: flags
为未来保留使用的，始终传入0。
Reserved for future use.

7、GCD总结

1、开不开线程，由执行任务的函数决定

  • 同步执行不开线程
  • 异步执行开线程

2、异步执行任务，开几条线程由队列决定

  • 串行队列，只会开一条线程，因为一条就足够了
  • 并发队列，可以开多条线程，具体开几条由线程池决定

对主队列而言，不管是同步执行还是异步执行，都不会开线程。

最后盗图总结一张

iOS多线程技术方案_第10张图片
842039-20161007133822817-1337794858.jpg

六、NSOperation

1、NSOperation简介

1.1 NSOperation与GCD的区别：

  • OC语言中基于 GCD 的面向对象的封装;
  • 使用起来比 GCD 更加简单;
  • 提供了一些用 GCD 不好实现的功能;
  • 苹果推荐使用，使用 NSOperation 程序员不用关心线程的生命周期

1.2NSOperation的特点

  • NSOperation 是一个抽象类，抽象类不能直接使用,必须使用它的子类
  • 抽象类的用处是定义子类共有的属性和方法

2、核心概念

将操作添加到队列，异步执行。相对于GCD创建任务，将任务添加到队列。

将NSOperation添加到NSOperationQueue就可以实现多线程编程

3、操作步骤

  • 先将需要执行的操作封装到一个NSOperation对象中
  • 然后将NSOperation对象添加到NSOperationQueue中
  • 系统会自动将NSOperationQueue中的NSOperation取出来
  • 将取出的NSOperation封装的操作放到一条新线程中执行

4、NSInvocationOperation

No1.

代码

- (void)viewDidLoad {
[super viewDidLoad];
//创建操作，然后调用操作的start方法
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(demo) object:nil];
NSLog(@"%d",op.isFinished);
[op start];
NSLog(@"%d",op.isFinished);
}

- (void)demo {
NSLog(@"hello %@",[NSThread currentThread]);
}

打印输出

2016-02-25 22:12:30.054 test[892:834660] 0
2016-02-25 22:12:30.054 test[892:834660] hello {number = 1, name = main}
2016-02-25 22:12:30.054 test[892:834660] 1

结论：[op start]在主线程中调用的，所以执行的线程也会是在主线程执行！ 重复调用start也只会执行一次，因为NSOperation会有一个属性去记住，是否已经完成了该操作！

No2.

代码

- (void)viewDidLoad {
[super viewDidLoad];
//    创建操作，将操作添加到NSOperationQueue中，然后就会异步的自动执行
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(demo) object:nil];
//队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//把操作添加到队列
[queue addOperation:op];
}

- (void)demo {
NSLog(@"hello %@",[NSThread currentThread]);
}
打印

2016-02-25 22:21:44.999 test[912:842412] hello {number = 2, name = (null)}

将操作添加到NSOperationQueue中，然后就会异步的自动执行

## 5、NSBlockOperation

**NSBlockOperation 中使用block的方式让所有代码逻辑在一起，使用起来更加简便。**

### NO1.

代码

//创建操作
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"hello %@",[NSThread currentThread]);
}];
//更新op的状态，执行main方法，不会开新线程
[op start];

输出

2016-02-25 22:25:30.442 test[923:846208] hello {number = 1, name = main}

NO2.

代码

// 创建队列，创建操作，将操作添加到队列中执行
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"hello %@",[NSThread currentThread]);
}];
[queue addOperation:op];

输出

2016-02-25 22:26:48.064 test[934:848038] hello {number = 2, name = (null)}

NO3.

代码

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

[queue addOperationWithBlock:^{
NSLog(@"hello %@",[NSThread currentThread]);

}];

2016-02-25 22:27:56.445 test[945:850128] hello {number = 2, name = (null)}

创建队列，添加block形式的操作
七、案例
线程之间的通信问题
技术方案：NSOperation

[self.queue addOperationWithBlock:^{
    NSLog(@"异步下载图片");
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
        NSLog(@"回到主线程，更新UI");
    }];
}];

技术方案：GCD

dispatch_async(dispatch_get_global_queue(0, 0), ^{
      NSLog(@"下载图片---%@",[NSThread currentThread]);
    dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"回到主线程刷新图片的显示 -%@",[NSThread currentThread]);
        });
    });

你可能感兴趣的:(iOS多线程技术方案)

  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 详解：如何设计出健壮的秒杀系统？ 夜空_2cd3
    作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
  • metaRTC/webRTC QOS 方案与实践 metaRTC metaRTC解决方案webrtcqos
    概述质量服务(QOS/QualityofService)是指利用各种技术方案提高网络通信质量的技术，网络通信质量需要解决下面两个问题：网络问题：UDP/不稳定网络/弱网下的丢包/延时/乱序/抖动数据量问题：发送数据量超带宽负载和平滑发送拥塞控制是各种技术方案的数据基础，丢包恢复解决丢包问题，抗乱序抖动解决网络乱序抖动问题，流量控制解决平滑发送数据/数据超带宽负载/延时问题。拥塞控制(Congest
  • 【JAVA】数据脱敏技术（对称加密算法、非对称加密算法、哈希算法、消息认证码（MAC）算法、密钥交换算法）使用方法 来一杯龙舌兰 Javajava开发语言数据脱敏技术加密算法AES
    文章目录数据脱敏的定义和目的数据脱敏的技术分类对称加密算法非对称加密算法哈希算法消息认证码（MAC）算法密钥交换算法数据脱敏的技术方案实现字符替换哈希算法（例如:SHA-3算法）消息认证码（MAC）算法(CMAC)消息认证码（MAC）算法(HMAC)对称/非对称加密实现方式（例如：AES加密算法）数据分段数据伪装更多相关内容可查看数据脱敏的定义和目的数据脱敏（DataMasking）是指对数据进行
  • 【iOS】GCD详解 cheng_lin0201 OCiOSiosobjective-c
    初识GCD深入理解GrandCentralDispatch(GCD)：iOS多线程编程的利器前言1.GCD简介1.1什么是GCD？1.2为什么使用GCD？2.GCD的核心概念2.1任务与队列2.2串行队列与并发队列3.GCD的API3.1DispatchQueue3.2dispatch_queue_create3.3MainDispatchQueue&GlobalDispatchQueue3.4d
  • 前端架构师的职责 acigt0531 前端gitViewUI
    前端架构师的职责没有文档的代码=放弃治疗作为前端架构师,首先要解决的问题就是让日益膨胀的代码可控,因此你需要梳理代码,建立架构,组织文档,管理架构的更新和维护,评审技术方案对架构的影响,核心模块的方案设计,重点项目的方案设计,CodeReview等.架构师和资深开发在工作职责上有着明确的界限,在一个没有架构师的团队,每一个资深开发或多或少都承担了一部分架构的工作,但都是破碎的,不成体系而且不统一,
  • 如何进行架构技术方案选型? 猫咪张 系统架构设计strutsspringmvcjsf架构设计ejb
    在架构设计时,通常面临的一个难题是,如何选择架构的技术方案.这也是各种项目都会碰到的问题.我们到底是选择C/S，B/S模式，如果选择C/S,那么到底是三层C/S还是两层，到底要不要分布式，B/S的展示层是自己写MVC，还是应用已有的开源的如SpringMVC，Struts2.0,JSF技术。总之，可选的确实是太多了。那么怎么去选择呢？这个问题确实有点难，但也有解决方法的。首先，我们需要研究我们项目
  • 秒杀系统如何保证库存不超卖 半桶水专家 Redis编程理论pythonredis开发语言
    在秒杀系统中，库存超卖是一个关键问题，需要通过多种技术手段来保证高并发情况下库存的正确性。以下是几种常见的解决库存超卖的技术方案及其具体实现方法。1.数据库乐观锁使用乐观锁可以防止多用户同时更新库存时导致超卖。乐观锁通常通过“版本号”机制来实现。实现步骤：在库存表中增加一个version字段。每次更新库存时，检查version是否与上次读取的一致，如果一致，则更新库存和version；如果不一致，
  • 快手HBase在千亿级用户特征数据分析中的应用与实践 王知无
    声明：本文的原文是来自Hbase技术社区的一个PPT分享，个人做了整理和提炼。大家注意哈，这种会议PPT类的东西能学习到的更多的是技术方案和他人在实践过程中的经验。希望对大家有帮助。背景快手每天产生数百亿用户特征数据，分析师需要在跨30-90天的数千亿特征数据中，任意选择多维度组合(如:城市=北京&性别=男)，秒级分析用户行为。针对这一需求,快手基于HBase自主研发了支持bitmap转化、存储、
  • NL2SQL技术方案系列(2)：全系列技术选型完整版：从通用技术选型(向量、图数据库)、大模型选择、Prompt工程、前沿技术方案展示 汀、人工智能 LLM工业级落地实践prompt人工智能自然语言处理大模型LLMNL2SQLText2SQL
    NL2SQL技术方案系列(2)：全系列技术选型完整版：从通用技术选型(向量、图数据库)、大模型选择、Prompt工程、前沿技术方案展示NL2SQL基础系列(1)：业界顶尖排行榜、权威测评数据集及LLM大模型（SpidervsBIRD）全面对比优劣分析[Text2SQL、Text2DSL]NL2SQL基础系列(2)：主流大模型与微调方法精选集，Text2SQL经典算法技术回顾七年发展脉络梳理NL2S
  • (游戏设计草稿) 《异界·召唤次元》 穷人小水滴 游戏人工智能3D开放世界角色扮演
    注意:以下仅为初步构思,仅供参考.(由于目前AI算力的限制,下述技术方案,可能在5~10年之后,才能成熟普及使用)目录:1初步设计2技术特点3全AI4可能的商业模式1初步设计《异界·召唤次元》以召唤为主要玩法的游戏.文案:赛星人所在的宇宙,与别的平行宇宙发生了部分时空重叠.这种重叠并不稳定,需要有天赋的赛星人(叠加者)召唤来自别的宇宙的物体(动物).每个叠加者对不同的异界体具有不同的契合度,契合度
  • NL2SQL技术方案系列(4)：金融领域NL2SQL技术方案以及行业案例实战讲解2 汀、人工智能 LLM工业级落地实践人工智能LLM自然语言处理NL2SQL大模型应用Text2SQLAI大模型
    NL2SQL技术方案系列(4)：金融领域NL2SQL技术方案以及行业案例实战讲解2NL2SQL基础系列(1)：业界顶尖排行榜、权威测评数据集及LLM大模型（SpidervsBIRD）全面对比优劣分析[Text2SQL、Text2DSL]NL2SQL基础系列(2)：主流大模型与微调方法精选集，Text2SQL经典算法技术回顾七年发展脉络梳理NL2SQL进阶系列(1)：DB-GPT-Hub、SQLco
  • 写的很全面的Redis高可用技术解决方案大全 JAVA架构师的圈子
    很多朋友向我咨询关于里面提到的高可用的方案的优缺点以及如何选择合适的方案线上使用，这里再整理发出来，供大家参考，如有不妥之处，欢迎批评指正，也欢迎推荐更好的技术方案。不废话了，来看看方案吧～Redis常见的几种主要使用方式：Redis单副本Redis多副本（主从）RedisSentinel（哨兵）RedisClusterRedis自研Redis各种使用方式的优缺点：1Redis单副本Redis单副
  • iOS多线程基础 星辰流转轮回
    什么是进程?进程是指系统中正在运行的一个程序,每个进程间是独立的,每个进程均运行在其专用且受保护的内存空间内.什么是线程?一个进程想要执行任务,必须得有线程.(每一个进程至少要有一个线程)一个进程中的所有任务都在线程中执行线程的串行一个线程中的所有任务的执行顺序都是串行的,也就是说,在同一时间内,一个线程只能执行一个任务.只有执行完上一个任务才可以执行下一个;也可以任务,线程是进程中的一条执行路径
  • PWA 简介 benwalker PWApwa前端
    PWA(ProgressiveWebApp)，即渐进式的web应用，是Google提出的让web应用可以达到原生应用使用体验的一整套技术方案。在2015年，提出这个概念时，引起人们很大的兴趣，很多网站也都进行了pwa的改造，包括YouTube，twitter等，并且在国内很多公司也进行了pwa的尝试，像微博。PWA现状但是目前来看，pwa的发展相对比较缓慢，因为一个web应用想要媲美原生应用的使用
  • Java设计模式 秋意钟 java设计模式开发语言
    设计模式概述设计模式(DesignPattern)是人们在长期的软件开发中对一些经验的总结，是对特点问题经过实践检验的特定解决方法。就像兵法中的三十六计，总结了多种对战争中某些特定的可能性计谋战术。设计模式使人们可以更加简单方便地复用成功的设计和体系结构。将已证实的技术方案总结成设计模式，也会是其他开发者更加容易理解其设计思路。设计模式是可复用的面向对象软件的基础，帮助开发者做出有利于系统复用的选
  • 基于RK3568智慧交通-雷达视频融合一体机，支持鸿蒙 深圳信迈科技DSP+ARM+FPGA 瑞芯微+FPGA音视频harmonyos华为
    智慧交通-雷达视频融合一体机随着5G网络与智慧交通车路协同系统在全国各点的落地，作为提升交通安全的前沿技术方案也愈发受到重视。在交通信控领域，以往的感知技术、无论是地磁、线圈还是摄像头，功能都仅仅局限于数清经过了多少车辆，无法满足交通数字化管理对精细化、智能化管控的需求。雷视融合一体机具备全天候和长距离的检测属性，除了统计车流量外，还可监测、跟踪车辆的运动行为特征，锁定车辆信息。同时，雷视融合一体
  • （十四）基于 Flink SQL 应用案例 springk Flink全景解析sql大数据实时数据处理实时数据flinkflinksql
    在11.11购物节大促活动中，天猫、京东等商家会对外发布购物节对应的交易金额、单量等信息，下面我们以2023.11.11购物节大促为背景，完成如下任务的计算：实时统计购物节当日从零点开始，截止到当前时间总交易额。基于销售的商品，按照品牌分类，每小时统计对应品牌下的总订单量。基于上面的应用场景，结合FlinkSQL，完成技术方案设计，并输出实现代码。目录问题1详解问题2详解问题1详解基于问题一，主要
  • Java导出分类到Excel 筱顾大men javaexcel开发语言easyexcel
    需求在一般需求中点击导出按钮可以把所有的分类导出到Excel文件中。技术方案使用EasyExcel实现Excel的导出操作。https://github.com/alibaba/easyexcelhttps://easyexcel.opensource.alibaba.com/docs/current/quickstart/write#%E7%A4%BA%E4%BE%8B%E4%BB%A3%E7%
  • （九）基于 Flink DataStream API 应用案例 springk Flink全景解析flink大数据实时数据实时数据处理开发语言
    在11.11购物节大促活动中，天猫、京东等商家会对外发布购物节对应的交易金额、单量等信息，下面我们以2023.11.11购物节大促为背景，完成如下任务的计算：问题1：每隔1秒统计购物节当日从零点开始，截止到当前时间总交易额。问题2：基于销售的商品，按照品牌分类，每小时统计对应品牌下的总订单量。基于上面的应用场景，结合DataStreamAPI，完成技术方案设计，并输出实现代码。目录问题1详解问题2
  • 专利申请撰写技巧和要求 尚标知识产权
    专利申请文件是申请人向专利局提交的重要文件，是获得专利保护的第一步。为了保证申请文件的顺利受理，申请人需要遵循一些撰写技巧和要求。本文将介绍这些技巧和要求，并帮助申请人更好地准备专利申请文件。在撰写专利申请文件时，申请人需要清楚地描述其发明的技术方案。这包括技术方案的实质特征、优点和技术效果等方面的详细描述。申请人应该尽可能地揭示其发明的创新之处，以便审查员更好地理解发明的技术内容，从而提高专利申
  • 谈一谈数据虚拟化的技术核心和应用架构 Aloudata DataFabric逻辑数据平台数据集成数据虚拟化
    数据虚拟化（DataVirtualization）是对数据资源的抽象，通过屏蔽数据资源的存储位置和访问方式，能够将不同数据源、不同格式的数据资源，进行逻辑上的整合集成。这一技术方案与过去面对传统数仓的弊端，业界过去经常采取的方式Presto方案有一定相似，但存在明显差别。Presto的架构本质上是一个MPP的引擎，其架构导致绝大部分使用Presto的场景都是在ETL最末端的消费层，本身面向的是OL
  • 智慧城市/雪亮工程中网页低延迟多屏播放海康威视大华华为等监控视频解决方案 猿大师办公助手 智慧城市音视频人工智能
    在传统安防项目中，一般视频监控系统采用的是C/S结构实现在电脑端或者手机端实时预览视频监控画面，但是随着智慧城市、雪亮工程、平安社区等项目在全国各地展开，视频监控系统更多应用在B/S结构项目上。但是普遍存在摄像头视频在网页中播放目前的技术难题，转码转流方案不仅延迟高，多路播放也会出现卡顿花屏等情况。不同于目前市场上其他厂商的服务器转码前端推流的落后技术方案，猿大师播放器采用独有的内嵌网页的专利技术
  • TypeScript 中的 type 和 interface：你真的了解它们的不同吗？
    如果你有写过Vue3的项目，那么对TypeScript肯定不会陌生。不管是公司新项目技术选型还是个人学习开发新的前端项目，Vue3+TypeScript已经成为首选技术方案之一在TypeScript这个强大的静态类型系统中，type和interface是两个重要的关键字，用于定义和描述数据类型。然而，这两者之间的区别是什么，在实际开发过程中我们要怎么用呢？废话不说，直接进入正题，就让我们一起深入探
  • websocket 实现原理和技术方案 静水流深，沧海一粟 浏览器APIwebsocket网络协议网络node前端javascript
    websocketWebSocket是HTML5开始提供的一种浏览器与服务器进行全双工通讯的网络技术，用以取代轮询与长连接，使客户端浏览器具备像C/S框架下桌面系统的即使通讯能力websocket协议是建立在tcp协议之上的，建立连接需要三次握手。websocket协议的连接过程：客户端连接服务器（TCP/IP），三次握手，建立了连接通道客户端发送一个http格式的消息（特殊格式），服务器也响应一
  • 分库分表浅析 大&迈 数据库
    简介对于任何系统而言，都会设计到数据库随着时间增长而累积越来越多的数据，系统也因为越来越多的需求变迁导致原有的设计不再满足现状，为了解决这些问题，分库分表就会走进视野，带着几个问题走入分库分表。什么是分库分表为什么要分库分表怎样分库分表分库分表后如何处理事务问题什么是分库分表分库分表是一种技术方案，为了解决单机数据块随着时间增长，数据量越来越大引起的数据库性能逐渐下滑。在上述定义中，分库分表主要是
  • 技术产品研发型企业的发展困境 数蚕
    目前中小企业想要发展自己的业务，必须使用到底层架构技术，于是企业多采用三种技术方案，一、招相关技术人员，并为之长期投入技术成本；二、使用相关开源技术框架，并培养相关业务人员；三、购买大型软件基础服务公司提供的云服务，并为之按量或时付费。其中方案一多为传统型生产型软件企业，其优点是人员稳定性强，研发周期稳定，市场发布规律，潜在用户群体流失性低；长期来看，对企业人员稳定，技术沉淀，都有着十分重要的贡献
  • 双盲插便携屏方案：LDR6020的引领与革新 legendary_163 计算机外设手机网络协议
    在当今这个高速发展的数字时代，双盲插便携屏方案作为一种创新的技术方案，正逐渐成为市场的新宠。而在这其中，LDR6020芯片发挥了至关重要的作用，推动了双盲插便携屏方案的普及与发展。本文将详细介绍双盲插便携屏方案的原理、特点以及LDR6020芯片的功能和优势。一、双盲插便携屏方案概述双盲插便携屏方案是一种新型的显示技术方案，其最大的特点是支持双盲插功能，即用户无需区分正反面，即可实现快速、稳定的连接
  • 01.Redis中间件实战1 airycode 深入浅出分布式缓存Redisredis中间件数据库
    Redis中间件实战1Redis各种数据结构实战字符串需求：将用户信息存储至缓存中，实现每次前端请求获取用户个人详情时直接从缓存中获取。来演示字符串的写入与读取。技术方案：为了实现这个需求，首先需要建立用户对象实体，里面包含用户个人的各种信息，包括ID、年龄、姓名、用户名及住址等，然后采用RedisTemplate操作组件将这一用户对象序列化为字符串信息并写入缓存中，最后从缓存中读取即可。publ
  • ＜分布式锁＞ 快乐的木子李 #Java基础分布式
    文章目录概要分布式锁实现1.数据库分布式锁2.redis分布式锁3.redis分布式锁小结概要在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。那具体什么是分布式锁，分布式锁应用在哪些业务场景、如何来实现分布式锁呢？为了保证一个方法或属性在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用并发处理相关的功能进行互斥控
  • springmvc 下 freemarker页面枚举的遍历输出 杨白白 enumfreemarker
    spring mvc freemarker 中遍历枚举 1枚举类型有一个本地方法叫values（），这个方法可以直接返回枚举数组。所以可以利用这个遍历。 enum public enum BooleanEnum { TRUE(Boolean.TRUE, "是"), FALSE(Boolean.FALSE, "否");
  • 实习简要总结 byalias 工作
    来白虹不知不觉中已经一个多月了，因为项目还在需求分析及项目架构阶段，自己在这段 时间都是在学习相关技术知识，现在对这段时间的工作及学习情况做一个总结： （1）工作技能方面 大体分为两个阶段，Java Web 基础阶段和Java EE阶段 1）Java Web阶段 在这个阶段，自己主要着重学习了 JSP, Servlet, JDBC, MySQL，这些知识的核心点都过 了一遍，也
  • Quartz——DateIntervalTrigger触发器 eksliang quartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208559 一.概述 simpleTrigger 内部实现机制是通过计算间隔时间来计算下次的执行时间，这就导致他有不适合调度的定时任务。例如我们想每天的 1：00AM 执行任务，如果使用 SimpleTrigger，间隔时间就是一天。注意这里就会有一个问题，即当有 misfired 的任务并且恢复执行时，该执行时间
  • Unix快捷键 18289753290 unixUnix；快捷键;
    复制，删除，粘贴： dd:删除光标所在的行                             &nbs
  • 获取Android设备屏幕的相关参数 酷的飞上天空 android
    包含屏幕的分辨率  以及 屏幕宽度的最大dp 高度最大dp   TextView text = (TextView)findViewById(R.id.text); DisplayMetrics dm = new DisplayMetrics(); text.append("getResources().ge
  • 要做物联网？先保护好你的数据 蓝儿唯美 数据
    根据Beecham Research的说法，那些在行业中希望利用物联网的关键领域需要提供更好的安全性。 在Beecham的物联网安全威胁图谱上，展示了那些可能产生内外部攻击并且需要通过快速发展的物联网行业加以解决的关键领域。 Beecham Research的技术主管Jon Howes说：“之所以我们目前还没有看到与物联网相关的严重安全事件，是因为目前还没有在大型客户和企业应用中进行部署，也就
  • Java取模（求余）运算 随便小屋 java
            整数之间的取模求余运算很好求，但几乎没有遇到过对负数进行取模求余，直接看下面代码： /** * * @author Logic * */ public class Test { public static void main(String[] args) { // TODO A
  • SQL注入介绍 aijuans sql注入
    二、SQL注入范例 这里我们根据用户登录页面 <form action="" > 用户名：<input type="text" name="username"><br/> 密 码：<input type="password" name="passwor
  • 优雅代码风格 aoyouzi 代码
    总结了几点关于优雅代码风格的描述： 代码简单：不隐藏设计者的意图，抽象干净利落，控制语句直截了当。 接口清晰：类型接口表现力直白，字面表达含义，API 相互呼应以增强可测试性。 依赖项少：依赖关系越少越好，依赖少证明内聚程度高，低耦合利于自动测试，便于重构。 没有重复：重复代码意味着某些概念或想法没有在代码中良好的体现，及时重构消除重复。 战术分层：代码分层清晰，隔离明确，
  • 布尔数组 百合不是茶 java布尔数组
      androi中提到了布尔数组;   布尔数组默认的是false,  并且只会打印false或者是true   布尔数组的例子;  根据字符数组创建布尔数组 char[] c = {'p','u','b','l','i','c'}; //根据字符数组的长度创建布尔数组的个数 boolean[] b = new bool
  • web.xml之welcome-file-list、error-page bijian1013 javaweb.xmlservleterror-page
    welcome-file-list 1.定义： <welcome-file-list> <welcome-file>login.jsp</welcome> </welcome-file-list>  2.作用：用来指定WEB应用首页名称。   error-page1.定义： <error-page&g
  • richfaces 4 fileUpload组件删除上传的文件 sunjing clearRichfaces 4fileupload
     页面代码               <h:form id="fileForm">            <rich:
  • 技术文章备忘 bit1129 技术文章
    Zookeeper http://wenku.baidu.com/view/bab171ffaef8941ea76e05b8.html http://wenku.baidu.com/link?url=8thAIwFTnPh2KL2b0p1V7XSgmF9ZEFgw4V_MkIpA9j8BX2rDQMPgK5l3wcs9oBTxeekOnm5P3BK8c6K2DWynq9nfUCkRlTt9uV
  • org.hibernate.hql.ast.QuerySyntaxException: unexpected token: on near line 1解决方案 白糖_ Hibernate
    文章摘自：http://blog.csdn.net/yangwawa19870921/article/details/7553181   在编写HQL时，可能会出现这种代码： select a.name,b.age from TableA a left join TableB b on a.id=b.id  如果这是HQL，那么这段代码就是错误的，因为HQL不支持
  • sqlserver按照字段内容进行排序 bozch 按照内容排序
    在做项目的时候，遇到了这样的一个需求：           从数据库中取出的数据集，首先要将某个数据或者多个数据按照地段内容放到前面显示，例如:从学生表中取出姓李的放到数据集的前面；          select * fro
  • 编程珠玑-第一章-位图排序 bylijinnan java编程珠玑
    import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.Writer; import java.util.Random; public class BitMapSearch {
  • Java关于==和equals chenbowen00 java
    关于==和equals概念其实很简单，一个是比较内存地址是否相同，一个比较的是值内容是否相同。虽然理解上不难，但是有时存在一些理解误区，如下情况： 1、 String a = "aaa"; a=="aaa"; ==> true 2、 new String("aaa")==new String("aaa
  • [IT与资本]软件行业需对外界投资热情保持警惕 comsci it
          我还是那个看法,软件行业需要增强内生动力,尽量依靠自有资金和营业收入来进行经营,避免在资本市场上经受各种不同类型的风险,为企业自主研发核心技术和产品提供稳定,温和的外部环境...       如果我们在自己尚未掌握核心技术之前,企图依靠上市来筹集资金,然后使劲往某个领域砸钱,然
  • oracle 数据块结构 daizj oracle块数据块块结构行目录
    oracle 数据块是数据库存储的最小单位，一般为操作系统块的N倍。其结构为： 块头－－〉空行－－〉数据，其实际为纵行结构。 块的标准大小由初始化参数DB_BLOCK_SIZE指定。具有标准大小的块称为标准块（Standard Block）。块的大小和标准块的大小不同的块叫非标准块（Nonstandard Block）。同一数据库中，Oracle9i及以上版本支持同一数据库中同时使用标
  • github上一些觉得对自己工作有用的项目收集 dengkane github
    github上一些觉得对自己工作有用的项目收集 技能类 markdown语法中文说明 回到顶部 全文检索 elasticsearch bigdesk elasticsearch管理插件 回到顶部 nosql mapdb 支持亿级别map, list, 支持事务. 可考虑做为缓存使用 C
  • 初二上学期难记单词二 dcj3sjt126com englishword
    dangerous 危险的 panda 熊猫 lion 狮子 elephant 象 monkey 猴子 tiger 老虎 deer 鹿 snake 蛇 rabbit 兔子 duck 鸭 horse 马 forest 森林 fall 跌倒；落下 climb 爬；攀登 finish 完成；结束 cinema 电影院；电影 seafood 海鲜；海产食品 bank 银行
  • 8、mysql外键(FOREIGN KEY)的简单使用 dcj3sjt126com mysql
    一、基本概念 1、MySQL中“键”和“索引”的定义相同，所以外键和主键一样也是索引的一种。不同的是MySQL会自动为所有表的主键进行索引，但是外键字段必须由用户进行明确的索引。用于外键关系的字段必须在所有的参照表中进行明确地索引，InnoDB不能自动地创建索引。 2、外键可以是一对一的，一个表的记录只能与另一个表的一条记录连接，或者是一对多的，一个表的记录与另一个表的多条记录连接。 3、如
  • java循环标签 Foreach shuizhaosi888 标签java循环foreach
    1. 简单的for循环 public static void main(String[] args) { for (int i = 1, y = i + 10; i < 5 && y < 12; i++, y = i * 2) { System.err.println("i=" + i + " y="
  • Spring Security（05）——异常信息本地化 234390216 exceptionSpring Security异常信息本地化
    异常信息本地化          Spring Security支持将展现给终端用户看的异常信息本地化，这些信息包括认证失败、访问被拒绝等。而对于展现给开发者看的异常信息和日志信息（如配置错误）则是不能够进行本地化的，它们是以英文硬编码在Spring Security的代码中的。在Spring-Security-core-x
  • DUBBO架构服务端告警Failed to send message Response javamingtingzhao 架构DUBBO
     废话不多说，警告日志如下，不知道有哪位遇到过，此异常在服务端抛出(服务器启动第一次运行会有这个警告)，后续运行没问题，找了好久真心不知道哪里错了。    WARN 2015-07-18 22:31:15,272 com.alibaba.dubbo.remoting.transport.dispatcher.ChannelEventRunnable.run(84)
  • JS中Date对象中几个用法 leeqq JavaScriptDate最后一天
    近来工作中遇到这样的两个需求 1. 给个Date对象，找出该时间所在月的第一天和最后一天 2. 给个Date对象，找出该时间所在周的第一天和最后一天   需求1中的找月第一天很简单，我记得api中有setDate方法可以使用 使用setDate方法前，先看看getDate var date = new Date(); console.log(date); // Sat J
  • MFC中使用ado技术操作数据库 你不认识的休道人 sqlmfc
    1.在stdafx.h中导入ado动态链接库 #import"C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","end")2.在CTestApp文件的InitInstance()函数中domodal之前写::CoIniti
  • Android Studio加速 rensanning android studio
    Android Studio慢、吃内存！启动时后会立即通过Gradle来sync & build工程。 （1）设置Android Studio a) 禁用插件 File -> Settings...  Plugins 去掉一些没有用的插件。 比如：Git Integration、GitHub、Google Cloud Testing、Google Cloud
  • 各数据库的批量Update操作 tomcat_oracle javaoraclesqlmysqlsqlite
    MyBatis的update元素的用法与insert元素基本相同，因此本篇不打算重复了。本篇仅记录批量update操作的 sql语句，懂得SQL语句，那么MyBatis部分的操作就简单了。 　　注意：下列批量更新语句都是作为一个事务整体执行，要不全部成功，要不全部回滚。 MSSQL的SQL语句 　WITH R AS（ 　　SELECT 'John' as name, 18 as
  • html禁止清除input文本输入缓存 xp9802 input
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off"; eg: <input type="text" autocomplete="off" name
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他