Ammar's Blog
微信号：aicjaish
首页 标签 分类 归档 留言 关于
多线程的实现方式
|iOS多线程
字数总计: 3.5k|阅读时长: 14 分钟

iOS中实现多线程的技术方案

pthread 实现多线程操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
代码实现：
void * run(void *param)
{
    for (NSInteger i = 0; i < 1000; i++) {
        NSLog(@"---buttonclick---%zd---%@", i, [NSThread currentThread]);
    }
    
    return NULL;
}

@implementation ViewController

- (IBAction)clickButton:(id)sender {
    // 定义一个线程
    pthread_t thread;
    
    // 创建一个线程  (参1)pthread_t *restrict:创建线程的指针，(参2)const pthread_attr_t *restrict:线程属性  (参3)void *(*)(void *):线程执行的函数的指针，(参4)void *restrict:null
    pthread_create(&thread, NULL, run, NULL);
    
    // 何时回收线程不需要你考虑
    pthread_t thread2;
    
    pthread_create(&thread2, NULL, run, NULL);

}

NSThread实现多线程

一个 NSThread 对象就代表一条线程

创建线程的多种方式

  • 第一种方式：先创建再启动线程

1
2
3
4
5
// 创建线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"jack"];

// 线程启动了，事情做完了才会死， 一个NSThread对象就代表一条线程
[thread start];
  • 第二种：直接创建并启动线程
1
2
// 直接创建并启动线程
[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"jack"];
  • 第三种：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 直接创建并启动线程
[self performSelectorInBackground:@selector(run:) withObject:@"jack"];

// 使线程进入阻塞状态
[NSThread sleepForTimeInterval:2.0];

#pragma mark - 执行run方法
- (void)run:(NSString *)param
{
    // 当前线程是否是主线程
    for (NSInteger i = 0; i < 100; i++) {
        NSLog(@"---%@---%zd---%d", [NSThread currentThread], i,  [NSThread isMainThread]);
    }
}

方法2和方法3的优点:快捷    方法1的优点:可以轻松拿到线程

线程间通信

  • 线程间通信的体现
    • 1个线程传递数据给另1个线程
    • 在1个线程中执行完特定任务后，转到另1个线程继续执行任务

线程间通信的常用方法：小程序图片下载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event 
{
    // 获取图片的url
    NSURL *url = [NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"];
// 另开1条线程 object用于数据的传递
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(downLoadWithURL:) object:url];
    // 由于下面下载图片的耗时太长，应领开启线程来完成
    [thread start];
}

// 下载图片
- (void)downLoadWithURL:(NSURL *)url
{
    NSLog(@"%@", [NSThread currentThread]);
    // 下载图片
    NSData *data = [NSData dataWithContentsOfURL:url];
    // 生成图片
    UIImage *image = [UIImage imageWithData:data];
    
    // 返回主线程显示图片
    [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES];
}

以上两种方式使用线程已经过时了，开发中我们操作线程大多都使用 GCD 和 NSOperation 来实现多线程操作。

下面我就给大家系统的介绍一下 GCD 是如何实现多线程的

GCD 实现多线程

GCD 简介

GCD 全称是Grand Central Dispatch，可译为“超级厉害的中枢调度器”，GCD 是苹果公司为多核的并行运算提出的解决方案， GCD会自动利用更多的 CPU 内核（比如双核、四核）来开启线程执行任务，GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程），不需要我们程序员手动管理内存。

任务和队列

任务：在同步函数和异步函数中执行
队列：用来存放任务（并发 串行）

GCD会自动将队列中的任务取出，放到对应的线程，任务的取出遵循FIFO，即先入先出队列，First Input First Output 的缩写。先进入的任务先完成并结束，再执行后面的任务。

同步函数和异步函数，并发队列和串行队列

  • 用同步的方式执行任务：在当前线程中可立即执行任务，不具备开启线程的能力

  • 用异步的方式执行任务：在当前线程结束时执行任务，具备开启新的线程的能力

  • 并发队列：允许多个任务同时执行

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

创建并发/串行队列代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 创建并发队列 
// 参1:const char *label 队列名称 
// 参2:dispatch_queue_attr_t attr 队列类型
dispatch_queue_t queueConcurrent = dispatch_queue_create("520it.com", DISPATCH_QUEUE_CONCURRENT);
    
// 创建串行队列  serial 串行  concurrent并发
dispatch_queue_t queueSerial = dispatch_queue_create("520it.com", DISPATCH_QUEUE_SERIAL);
    
// 获取全局队列 全局队列是并发队列 
// 参1:队列的优先级 
// 参2:0(以后可能用到的参数)
dispatch_queue_t queueGlobal = 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 // 后台
    
// 获取主队列  在主队列中的任务都会在主线程中执行。
dispatch_queue_t queueMain = dispatch_get_main_queue();

同步/异步函数代码表示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// GCD同步函数串行队列(立即执行，当前线程) 
// 参1: dispatch_queue_t queue 队列 
// 参2: 任务
dispatch_sync(queueSerial, ^{
	for (NSInteger i = 0; i < 10; i++) {
		NSLog(@"~~~%@", [NSThread currentThread]);
   }
});
    
// 同步函数并行队列(立即执行，当前线程)
dispatch_sync(queueConcurrent, ^{
	for (NSInteger i = 0; i < 10; i++) {
		NSLog(@"~~~%@", [NSThread currentThread]);
	}
});
    
// 异步函数串行队列 (另开线程，多个任务按顺序执行)
dispatch_async(queueSerial, ^{
	dispatch_async(queueSerial, ^{
		for (NSInteger i = 0; i < 10; i++) {
			NSLog(@"~~~%@", [NSThread currentThread]);
		}
	});
	dispatch_async(queueSerial, ^{
		for (NSInteger i = 0; i < 10; i++) {
			NSLog(@"~~~%@", [NSThread currentThread]);
		}
	});
	dispatch_async(queueSerial, ^{
		for (NSInteger i = 0; i < 10; i++) {
			NSLog(@"~~~%@", [NSThread currentThread]);
		}
	});
});
    
// 异步函数并行队列 (另开线程，多个任务一起执行)
dispatch_async(queueConcurrent, ^{
	dispatch_async(queueSerial, ^{
			for (NSInteger i = 0; i < 10; i++) {
				NSLog(@"~~~%@", [NSThread currentThread]);
			}
	});
	dispatch_async(queueSerial, ^{
		for (NSInteger i = 0; i < 10; i++) {
			NSLog(@"~~~%@", [NSThread currentThread]);
		}
	});
	dispatch_async(queueSerial, ^{
		for (NSInteger i = 0; i < 10; i++) {
			NSLog(@"~~~%@", [NSThread currentThread]);
		}
	});
});
    
// 主队列:(任何一个任务只要在主队列中，都会加入到主线程的队列中执行)

注意
使用sync函数(同步函数)往当前串行队列中添加任务，会卡住当前的串行队列

解释：使用同步函数添加任务 A 到串行队列，说明要在当前串行队列立即执行任务 A ，任务 A 执行完后，才会执行任务 A 后面的代码。但当前队列是串行队列，也就是说任务 A 必须等到当前串行队列中正在执行的任务 B 完成之后才能执行，因此又必须先执行任务 A 中立即执行任务，又要必须等到任务 B 执行完以后才能执行下一个任务，所以就会卡死。你等我，我等你，谁也无法执行。

GCD实现线程通信

小项目：下载图片

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 获取图片的url
NSURL *url = [NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"];
    
// 开启线程下载图片
dispatch_queue_t queue = dispatch_queue_create("111", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{
	NSData *data = [NSData dataWithContentsOfURL:url];
	UIImage *image = [UIImage imageWithData:data];
	
	// 下载完成后返回主线程显示图片
	dispatch_async(dispatch_get_main_queue(), ^{
		self.imageView.image = image;
	});
});

GCD其他常用函数

dispatch_barrier 栅栏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 1.barrier : 在barrier前面的先执行，然后再执行barrier，然后再执行barrier后面的 barrier的queue不能是全局的并发队列
dispatch_queue_t queue = dispatch_queue_create("11", DISPATCH_QUEUE_CONCURRENT);
    
dispatch_async(queue, ^{
	for (int i = 0;  i < 100; i++) {
		NSLog(@"%@--1", [NSThread currentThread]);
	}
});
    
dispatch_async(queue, ^{
	for (int i = 0;  i < 100; i++) {
		NSLog(@"%@--2", [NSThread currentThread]);
	}
});
    
dispatch_barrier_async(queue, ^{
	for (int i = 0;  i < 100; i++) {
		NSLog(@"%@--3", [NSThread currentThread]);
	}
});
    
dispatch_async(queue, ^{
	for (int i = 0;  i < 100; i++) {
		NSLog(@"%@--4", [NSThread currentThread]);
	}
});

dispatch_after 延迟执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 延迟执行
// 方法1
[self performSelector:@selector(run:) withObject:@"参数" afterDelay:2.0];

// 方法2
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
	for (NSInteger i = 0; i < 100; i++) {
		NSLog(@"%@", [NSThread currentThread]);
	}
});

// 方法3
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];
```	

#### dispatch_once 整个程序运行中执行一次

```objc

// 整个程序中只执行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
	// 一次性代码
});

作用：实现某个类的单粒对象

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static id _person;
+ (instancetype)sharePerson
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _person = [[super alloc] init];
    });
    return _person;
}
	
+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _person = [super allocWithZone:zone];
    });
    return _person;
}
	
- (id)copy
{
    return _person;
}

开发中一般自定义成宏，比较方便，一行代码搞定。

dispatch_apply 快速迭代

示例小程序：将一个文件夹中的图片剪切到另一个文件夹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 将图片剪切到另一个文件夹里
NSString *from = @"/Users/Ammar/Pictures/壁纸";
NSString *to = @"/Users/Ammar/Pictures/to";
NSFileManager *manager = [NSFileManager defaultManager];
NSArray *subPaths = [manager subpathsAtPath:from];

// 快速迭代
dispatch_apply(subPaths.count, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t index) {
   NSLog(@"%@ - %zd", [NSThread currentThread], index);
	NSString *subPath = subPaths[index];
	NSString *fromPath = [from stringByAppendingPathComponent:subPath];
	NSString *toPath = [to stringByAppendingPathComponent:subPath];
        
	// 剪切
	[manager moveItemAtPath:fromPath toPath:toPath error:nil];
	NSLog(@"%@---%zd", [NSThread currentThread], index);
});

dispatch_group 队列组

示例小程序：需求下载图片1 下载图片2 将图片1和图片2合成新的图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 创建队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
// 创建组
dispatch_group_t group = dispatch_group_create();
    
// 用组队列下载图片1
dispatch_group_async(group, queue, ^{
	NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"]];
	self.image1 = [UIImage imageWithData:data];
	NSLog(@"1%@", [NSThread currentThread]);
});

// 用组队列下载图片2
dispatch_group_async(group, queue, ^{
	NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"]];
	self.image2 = [UIImage imageWithData:data];
	NSLog(@"2%@", [NSThread currentThread]);
});
    
// 将图片1和图片2合成一张图片
dispatch_group_notify(group, queue, ^{
	CGFloat imageW = self.imageView.bounds.size.width;
	CGFloat imageH = self.imageView.bounds.size.height;

	// 开启位图上下文
	UIGraphicsBeginImageContext(self.imageView.bounds.size);
        
	// 画图
	[self.image1 drawInRect:CGRectMake(0, 0, imageW * 0.5, imageH)];
	[self.image2 drawInRect:CGRectMake(imageW * 0.5, 0, imageW * 0.5, imageH)];
        
	// 将图片取出
	UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
   
	// 关闭图形上下文
	UIGraphicsEndImageContext();
        
	// 在主线程上显示图片
	dispatch_async(dispatch_get_main_queue(), ^{
		self.imageView.image = image;
	});
	NSLog(@"3%@", [NSThread currentThread]);
});

GCD定时器

GCD定时器不受Mode影响因此比NSTimer要准确

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

static int count = 0;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
	// 这句话的意思现在很好懂了
});
    
// GCD定时器
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
// 1.创建一个定时器源
    
// 参1:类型定时器
// 参2:句柄 
// 参3:mask传0 
// 参4:队列  (注意:dispatch_source_t本质是OC对象，表示源)
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    
// 严谨起见，时间间隔需要用单位int64_t，做乘法以后单位就变了
// 下面这句代码表示回调函数时间间隔是多少
int64_t interval = (int64_t)(2.0 * NSEC_PER_SEC); 

// 如何设置开始时间 CGD给我们了一个设置时间的方法  
// 参1:dispatch_time_t when 传一个时间， delta是增量

dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)); // 从现在起3秒后开始
    
// 2.设置定时器的各种属性
	
// 参1:timer 
// 参2:开始时间 
// 参3:时间间隔 
// 参4:传0 不需要   DISPATCH_TIME_NOW 表示现在 GCD 时间用 NS 表示
dispatch_source_set_timer(self.timer, start, interval, 0);
    
    
// 3.设置回调(即每次间隔要做什么事情)
dispatch_source_set_event_handler(self.timer, ^{
	NSLog(@"----------------%@", [NSThread currentThread]);
        
	// 如果希望做5次就停掉
	count++;
	if (count == 5) {
		dispatch_cancel(self.timer);
		self.timer = nil;
	}
});
    
// 4.启动定时器  (恢复)
dispatch_resume(self.timer);

讲完 GCD 就该讲讲 NSOperation，它是 GCD 的面向对象的封装，使用起来也更方便，

NSOperation实现多线程

NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类

  • NSInvocationOperation
  • NSBlockOperation
  • 自定义子类继承NSOperation，实现内部相应的方法

使用 NSOperation 实现多线程的步骤：

  1. 创建任务 NSOperation 对象
  2. 创建 NSOperationQueue 队列
  3. 将任务 NSOperation 对象 add 到 NSOperationQueue 队列中去

NSInvocationOperation

代码如下：

1
2
3
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

[op start];

注意：默认情况下，调用了start方法后并不会开一条新的线程去执行，而是在当前线程同步执行操作，只有将 NSOperation 放到一个 NSOperationQueue 中，才会异步执行操作

NSBlockOperation

1
2
3
4
5
6
7
8
9
10
11
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
	// 在主线程
  	NSLog(@"下载1------%@", [NSThread currentThread]);
}];
    
// 添加额外的任务(在子线程执行)，封装数大于1才会异步执行
[op addExecutionBlock:^{
	NSLog(@"下载2------%@", [NSThread currentThread]);
}];

自定义Operation：需要实现- (void)main方法，需要做的事情放在mian方法中

NSOperationQueue

使用NSOperationQueue创建队列：主队列和全局队列

1
2
3
4
5
6
7
8
9
// 创建一个其他队列(包括串行队列和并发队列) 放到这个队列中的NSOperation对象会自动放到子线程中执行

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

// 创建一个主队列，放到这个队列中的NSOperation对象会自动放到子线程中执行
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

// 表示并发数量：即同时执行任务的最大数。
queue.maxConcurrentOperationCount = 1;

队列的取消、暂停、恢复：

1
2
3
4
// NSOpertion的 - cancel 方法也可以停止单个操作
- (void)cancelAllOperations; 
// YES代表暂停队列，NO代表恢复队列
- (void)setSuspended:(BOOL)b;

添加依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *block1 = [NSBlockOperation blockOperationWithBlock:^{
	NSLog(@"download1 -------------- %@", [NSThread currentThread]);
}];
    
NSBlockOperation *block2 = [NSBlockOperation blockOperationWithBlock:^{
	NSLog(@"download2 -------------- %@", [NSThread currentThread]);
}];
    
NSBlockOperation *block3 = [NSBlockOperation blockOperationWithBlock:^{
	NSLog(@"download3 -------------- %@", [NSThread currentThread]);
}];
    
// 添加依赖: block1 和 block2执行完后 再执行 block3  block3依赖于block1和block2
    
// 给block3添加依赖 让block3在block1和block2之后执行
[block3 addDependency:block1];
[block3 addDependency:block2];
    
[queue addOperation:block1];
[queue addOperation:block2];
[queue addOperation:block3];

注意：不能循环依赖，但可以跨队列依赖，不管NSOperation对象在哪个队列。只要是两个NSOperation对象就可以依赖

线程间通信

示例：下载图片

1
2
3
4
5
6
7
8
9
10
11

// 下载图片 operation实现线程间通信
[[[NSOperationQueue alloc] init] addOperation:[NSBlockOperation blockOperationWithBlock:^{
	UIImage *image = [UIImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"]]];
        
	// 返回主线程
	[[NSOperationQueue mainQueue] addOperation:[NSBlockOperation blockOperationWithBlock:^{
		self.imageView.image = image;
	}]];
        
}]];

示例：下载图片1和图片2 并合成图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
// 下载图片1
__block UIImage *image1 = nil;
NSBlockOperation *block1 = [NSBlockOperation blockOperationWithBlock:^{
	image1 = [UIImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"]]];
}];
    
// 下载图片2
__block UIImage *image2 = nil;
NSBlockOperation *block2 = [NSBlockOperation blockOperationWithBlock:^{
	image2 = [UIImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:@"https://7xjanq.com1.z0.glb.clouddn.com/6478.jpg"]]];

}];
    
CGFloat imageW = self.imageView.bounds.size.width;
CGFloat imageH = self.imageView.bounds.size.height;
    
// 合成图片
NSBlockOperation *block3 = [NSBlockOperation blockOperationWithBlock:^{
	UIGraphicsBeginImageContext(CGSizeMake(imageW, imageH));
	[image1 drawInRect:CGRectMake(0, 0, imageW * 0.5, imageH)];
	[image2 drawInRect:CGRectMake(0.5 * imageW, 0, 0.5 * imageW, imageH)];
        
	UIImage *image3 = UIGraphicsGetImageFromCurrentImageContext();
	UIGraphicsEndImageContext();
	// 切换回主线程显示图片
	[[NSOperationQueue mainQueue] addOperation:[NSBlockOperation blockOperationWithBlock:^{
		self.imageView.image = image3;
	}]];
    
}];
    
// 设置依赖
[block3 addDependency:block1];
[block3 addDependency:block2];
    
// 添加任务到队列中
[queue addOperation:block1];
[queue addOperation:block2];
[queue addOperation:block3];

应用

应用：SDWebImage 框架的底层主要功能实现就是基于多线程，使用多线程，我们可以实现小图片的多图片下载。这里的逻辑其实是比较复杂的

实现小图片的多图片下载思路：

代码实现见本文代码。

本文代码见：Multithreading

文章作者: Ammar
文章链接: http://lizhaoloveit.cn/2015/03/06/%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Ammar's Blog！
iOS
打赏
  • 微信
  • 支付宝
评论
繁