文档章节

IOS 多线程(中)

古乙丁三雨
 古乙丁三雨
发布于 2017/06/26 14:05
字数 3539
阅读 21
收藏 0

IOS 多线程(中)

GCD

  1. GCD 简介

    Grand Central Dispatch (GCD) 是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。

  2. GCD 特点

    • GCD可用于多核的并行运算
    • GCD会自动利用更多的CPU内核(比如双核、四核)
    • GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
    • 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码
  3. 任务与队列

    任务:就是执行操作的意思,换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式:同步执行和异步执行。两者的主要区别是:是否具备开启新线程的能力。

    • 同步执行(sync):只能在当前线程中执行任务,不具备开启新线程的能力
    • 异步执行(async):可以在新的线程中执行任务,具备开启新线程的能力

    队列:这里的队列指任务队列,即用来存放任务的队列。队列是一种特殊的线性表,采用FIFO(先进先出)的原则,即新任务总是被插入到队列的末尾,而读取任务的时候总是从队列的头部开始读取。每读取一个任务,则从队列中释放一个任务。在GCD中有两种队列:串行队列和并发队列。

    • 并发队列(Concurrent Dispatch Queue):可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
    • 串行队列(Serial Dispatch Queue):让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
  4. GCD的使用步骤

    GCD的使用步骤其实很简单,只有两步。

    1、创建一个队列(串行队列或并发队列)

    2、将任务添加到队列中,然后系统就会根据任务类型执行任务(同步执行或异步执行) 下边来看看队列的创建方法和任务的创建方法。

    可以使用dispatch_queue_create来创建对象,需要传入两个参数,第一个参数表示队列的唯一标识符,用于DEBUG,可为空;第二个参数用来识别是串行队列还是并发队列。

    DISPATCH_QUEUE_SERIAL表示串行队列,DISPATCH_QUEUE_CONCURRENT表示并发队列。

    	// 串行队列的创建方法
    

dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL); // 并发队列的创建方法 dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT); ```

对于并发队列,还可以使用```dispatch_get_global_queue```来创建全局并发队列。GCD默认提供了全局的并发队列,需要传入两个参数。第一个参数表示队列优先级,一般用```DISPATCH_QUEUE_PRIORITY_DEFAULT```。第二个参数暂时没用,用0即可。

任务的创建方法:

```
// 同步执行任务创建方法

dispatch_sync(queue, ^{ NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码 }); // 异步执行任务创建方法 dispatch_async(queue, ^{ NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码 });

```

虽然使用GCD只需两步,但是既然我们有两种队列,两种任务执行方式,那么我们就有了四种不同的组合方式。这四种不同的组合方式是


>1. 并发队列 + 同步执行
>2. 并发队列 + 异步执行
>3. 串行队列 + 同步执行
>4. 串行队列 + 异步执行

实际上,我们还有一种特殊队列是主队列,那样就有六种不同的组合方式了。
>1. 主队列 + 同步执行
>2. 主队列 + 异步执行
  1. GCD的基本使用

    • 并发队列 + 同步执行
        dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });
从上至下,一个一个依次执行,

* 并发队列 + 异步执行
- (void) asyncConcurrent
	{
	    NSLog(@"asyncConcurrent---begin");
	
	    dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
	
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"1------%@",[NSThread currentThread]);
	        }
	    });
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"2------%@",[NSThread currentThread]);
	        }
	    });
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"3------%@",[NSThread currentThread]);
	        }
	    });
	
	    NSLog(@"asyncConcurrent---end");
	}

输出结果:

输出结果: 2016-09-03 19:27:31.503 GCD[11595:1901548] asyncConcurrent---begin 2016-09-03 19:27:31.504 GCD[11595:1901548] asyncConcurrent---end 2016-09-03 19:27:31.504 GCD[11595:1901626] 1------<NSThread: 0x7f8309c22080>{number = 2, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901625] 2------<NSThread: 0x7f8309f0b790>{number = 4, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901855] 3------<NSThread: 0x7f8309e1a950>{number = 3, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901626] 1------<NSThread: 0x7f8309c22080>{number = 2, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901625] 2------<NSThread: 0x7f8309f0b790>{number = 4, name = (null)} 2016-09-03 19:27:31.505 GCD[11595:1901855] 3------<NSThread: 0x7f8309e1a950>{number = 3, name = (null)}

在并发队列 + 异步执行中可以看出,除了主线程,又开启了3个线程,并且任务是交替着同时执行的。

另一方面可以看出,所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行,而是将所有任务添加到队列之后才开始异步执行。

  • 串行队列 + 同步执行

    不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务

    	- (void) syncSerial
    	{
    	    NSLog(@"syncSerial---begin");
    
    	    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
    
    	    dispatch_sync(queue, ^{
    	        for (int i = 0; i < 2; ++i) {
    	            NSLog(@"1------%@",[NSThread currentThread]);
    	        }
    	    });    
    	    dispatch_sync(queue, ^{
    	        for (int i = 0; i < 2; ++i) {
    	            NSLog(@"2------%@",[NSThread currentThread]);
    	        }
    	    });
    	    dispatch_sync(queue, ^{
    	        for (int i = 0; i < 2; ++i) {
    	            NSLog(@"3------%@",[NSThread currentThread]);
    	        }
    	    });
    
    	    NSLog(@"syncSerial---end");
    	}
    

    输出结果:

    2016-09-03 19:29:00.066 GCD[11622:1903904] syncSerial---begin 2016-09-03 19:29:00.067 GCD[11622:1903904] 1------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 1------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 2------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 2------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 3------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.068 GCD[11622:1903904] 3------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.068 GCD[11622:1903904] syncSerial---end

    立即执行、所以按顺序一个一个执行。

    • 串行队列 + 异步执行
	- (void) asyncSerial
	{
	    NSLog(@"asyncSerial---begin");
	
	    dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
	
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"1------%@",[NSThread currentThread]);
	        }
	    });    
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"2------%@",[NSThread currentThread]);
	        }
	    });
	    dispatch_async(queue, ^{
	        for (int i = 0; i < 2; ++i) {
	            NSLog(@"3------%@",[NSThread currentThread]);
	        }
	    });
	
	    NSLog(@"asyncSerial---end");
	}
	```
输出结果
>2016-09-03 19:30:08.363 GCD[11648:1905817] asyncSerial---begin
	
>2016-09-03 19:30:08.364 GCD[11648:1905817] asyncSerial---end
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 1------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 1------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 2------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 2------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.365 GCD[11648:1905895] 3------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.365 GCD[11648:1905895] 3------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
   在串行队列 + 异步执行可以看到,开启了一条新线程,但是任务还是串行,所以任务是一个一个执行。
	
   一方面可以看出,所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行,而是将所有任务添加到队列之后才开始同步执行。
		
6. 主队列
	
	主队列是GCD自带的一种特殊的串行队列,所有放在主队列中的任务,都会放到主线程中执行。由于UI刷新只能在主线程中执行,这个队列对于界面刷新尤其重要
	
	可使用```dispatch_get_main_queue```()获得主队列
	
	* 主队列+同步

- (void)syncMain
{
    NSLog(@"syncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });   

    NSLog(@"syncMain---end");
}
输出结果
>2016-09-03 19:32:15.356 GCD[11670:1908306] syncMain---begin
	
  这时候,我们惊奇的发现,在主线程中使用主队列 + 同步执行,任务不再执行了,而且syncMain---end也没有打印。这是为什么呢?

   这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中,也就是放到了主线程的队列中。而同步执行有个特点,就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中,它就会立马执行。但是主线程现在正在处理syncMain方法,所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候,又要等第一个任务执行完才能往下执行第二个和第三个任务。

  那么,现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待,所以就卡住了,所以我们的任务执行不了,而且syncMain---end也没有打印。
	
* 主队列 + 异步执行

- (void)asyncMain
{
    NSLog(@"asyncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"1------%@",[NSThread currentThread]);
        }
    });    
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"2------%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 2; ++i) {
            NSLog(@"3------%@",[NSThread currentThread]);
        }
    });  

    NSLog(@"asyncMain---end");
}
	
输出结果:
>2016-09-03 19:33:54.995 GCD[11706:1911313] asyncMain---begin
2016-09-03 19:33:54.996 GCD[11706:1911313] asyncMain---end
2016-09-03 19:33:54.996 GCD[11706:1911313] 1------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 1------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3------<NSThread: 0x7fb623d015e0>{number = 1, name = main}

主队列也是串行队列,所以一个一个的处理下去,因为是异步线程,所以不会立即执行(要是理解了上面的,也就不难理解这里了)
	 
7. GCD线程之间的通讯(最常用的喔!)	

在iOS开发过程中,我们一般在主线程里边进行UI刷新,例如:点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程,比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时,需要回到主线程,那么就用到了线程之间的通讯。 

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ for (int i = 0; i < 2; ++i) { NSLog(@"1------%@",[NSThread currentThread]); }

    // 回到主线程
    dispatch_async(dispatch_get_main_queue(), ^{
    	// 我们经常会在这里做一些ui刷新操作
        NSLog(@"2-------%@",[NSThread currentThread]);
    });
});


```

输出结果: 2016-09-03 19:34:59.165 GCD[11728:1913039] 1------<NSThread: 0x7f8319c06820>{number = 2, name = (null)} 2016-09-03 19:34:59.166 GCD[11728:1913039] 1------<NSThread: 0x7f8319c06820>{number = 2, name = (null)} 2016-09-03 19:34:59.166 GCD[11728:1912961] 2-------<NSThread: 0x7f8319e00560>{number = 1, name = main}

  1. GCD的其他方法

    • GCD的栅栏方法

      我们有时需要异步执行两组操作,而且第一组操作执行完之后,才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来,当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

      	- (void)barrier
      	{
      	    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);
      
      	    dispatch_async(queue, ^{
      	        NSLog(@"----1-----%@", [NSThread currentThread]);
      	    });
      	    dispatch_async(queue, ^{
      	        NSLog(@"----2-----%@", [NSThread currentThread]);
      	    });
      
      	    dispatch_barrier_async(queue, ^{
      	        NSLog(@"----barrier-----%@", [NSThread currentThread]);
      	    });
      
      	    dispatch_async(queue, ^{
      	        NSLog(@"----3-----%@", [NSThread currentThread]);
      	    });
      	    dispatch_async(queue, ^{
      	        NSLog(@"----4-----%@", [NSThread currentThread]);
      	    });
      	}
      

      输出结果:

      2016-09-03 19:35:51.271 GCD[11750:1914724] ----1-----<NSThread: 0x7fb1826047b0>{number = 2, name = (null)}

      2016-09-03 19:35:51.272 GCD[11750:1914722] ----2-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}

      2016-09-03 19:35:51.272 GCD[11750:1914722] ----barrier-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}

      2016-09-03 19:35:51.273 GCD[11750:1914722] ----3-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}

      2016-09-03 19:35:51.273 GCD[11750:1914724] ----4-----<NSThread: 0x7fb1826047b0>{number = 2, name = (null)}

      可以看出在执行完栅栏前面的操作之后,才执行栅栏操作,最后再执行栅栏后边的操作。

    • GCD的延时执行方法

      当我们需要延迟执行一段代码时,就需要用到GCD的dispatch_after方法。

      	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
      	    // 2秒后异步执行这里的代码...
      	   NSLog(@"run-----");
      	});
      
    • GCD的一次性代码(只执行一次)

      我们在创建单例、或者有整个程序运行过程中只执行一次的代码时,我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。

      	static dispatch_once_t onceToken;
      

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

* GCD的快速迭代方法

	通常我们会用for循环遍历,但是GCD给我们提供了快速迭代的方法```dispatch_apply```,使我们可以同时遍历。比如说遍历0~5这6个数字,for循环的做法是每次取出一个元素,逐个遍历。```dispatch_apply```可以同时遍历多个数字。
	
	```
	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

	dispatch_apply(6, queue, ^(size_t index) {
	    NSLog(@"%zd------%@",index, [NSThread currentThread]);
	});
	```
	
	输出结果:
	>2016-09-03 19:37:02.250 GCD[11764:1915764] 1------<NSThread: 0x7fac9a7029e0>{number = 1, name = main}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915885] 0------<NSThread: 0x7fac9a614bd0>{number = 2, name = (null)}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915886] 2------<NSThread: 0x7fac9a542b20>{number = 3, name = (null)}
	
	>2016-09-03 19:37:02.251 GCD[11764:1915764] 4------<NSThread: 0x7fac9a7029e0>{number = 1, name = main}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915884] 3------<NSThread: 0x7fac9a76ca10>{number = 4, name = (null)}
	
	>2016-09-03 19:37:02.251 GCD[11764:1915885] 5------<NSThread: 0x7fac9a614bd0>{number = 2, name = (null)}
	
	从输出结果中前边的时间中可以看出,几乎是同时遍历的。
	
* GCD的队列组

有时候我们会有这样的需求:分别异步执行2个耗时操作,然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。
比如我们同时下载十个文件,等这十个文件下载完再提示成功,我们就可以把这十个下载放入group中

* 我们可以先把任务放到队列中,然后将队列放入队列组中。调用队列组的```dispatch_group_notify```回到主线程执行操作。

* 我们可以先把任务放到队列中,然后将队列放入队列组中。调用队列组的```dispatch_group_notify```回到主线程执行操作。

```
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 多线程(上)

下一篇IOS 多线程(下)

© 著作权归作者所有

上一篇: IOS 多线程(下)
下一篇: IOS 多线程(上)
古乙丁三雨
粉丝 2
博文 60
码字总数 30969
作品 0
景德镇
程序员
私信 提问
加载中

评论(1)

古乙丁三雨
古乙丁三雨
写的这么好都没人赞
如何判断你是合格的高级iOS开发工程师?

前言 随着移动互联网的高速发展泄洪而来,有意学习移动开发的人越来越多了,竞争也是越来越大,需要学习的东西很多。如何才能在激烈的移动开发者竞争中一枝独秀,成为一名真正合格的高级iOS...

_小迷糊
2018/05/26
0
0
iOS开发的你,现在准备脱坑还是继续进阶呢?

序言 我相信很多人都在说,iOS行业不好了,iOS现在行情越来越难了,失业的人比找工作的人还要多。失业即相当于转行,跳槽即相当于降低自己的身价。那么做iOS开发的你,你是否在时刻准备着跳槽...

_小迷糊
2018/10/31
0
0
iOS高仿微信项目、阴影圆角渐变色效果、卡片动画、波浪动画、路由框架等源码

iOS精选源码 iOS高仿微信完整项目源码(http://www.code4app.com/thread-14695-1-1.html) Khala: Swift 编写的iOS/macOS 路由框架(http://www.code4app.com/thread-31586-1-1.html) 微信左滑删......

Android爱开源
01/03
0
0
为何提高iOS技能?

如题,我的困惑 去年11月份自学,今年3月份辞职正式转型做iOS工作,但是项目一直到6月份都是自己做,感觉提升很慢,算是个中级偏下水平 求教iOS朋友,你们是怎么提升自己的? 书单 《Effecti...

卧龙小
2015/09/18
1K
11
2018 iOS 面试题大全(补充完整版)

原文地址:2018 iOS 面试题大全 由于原作者并没有继续更新,这里我转过来继续更新下 这个栏目将持续更新--请iOS的小伙伴关注! 1、iOS 应用导航模式有哪些? 2、iOS 中持久化方式有哪些? 3、...

Theendisthebegi
2018/11/15
0
0

没有更多内容

加载失败,请刷新页面

加载更多

任务调度-单体应用定时任务解决方案

1. 应用场景: 单体应用(并发少、就公司内部使用)、业务比较简单、单一、稳定,传统行业首选,项目初期。 2. 主要方式: Spring XML配置方式,timer。 <bean id="cycleBonusTimer" class="...

秋日芒草
8分钟前
0
0
EditText中singleLine过期替代方法

android:lines="1" android:inputType="text"

球球
22分钟前
0
0
删除 Tomcat-webapps 目录自带项目

本文将 %CATALINA_HOME% 目录称为“tomcat”目录。 1.webapps目录中的项目 在 Tomcat 8.0 的 tomcat/webapps 目录中,含有 5 个 Tomcat 自带的 Web 项目,如下所示: docs 有关于 Tomcat 的介...

Airship
26分钟前
2
0
好文:华杉:我等用功,不求日增,但求日减。减一分人欲,则增一分天理,这是何等简易!何等洒脱!

#写在前面1.怎么理解“减一分人欲,则增一分天理,这是何等简易!”?1)华杉提倡 “一劳永逸” 排除浪费,少干活,多赚钱,一战而定,降低作业成本。2)华杉提倡学海无涯,回头是岸...

阿锋zxf
36分钟前
3
0
vue 的bus总线

bus声明 global.bus = new Vue() 事件发送 controlTabbar () {global.bus.$emit('pickUp', 'ddd')}, 事件接收 global.bus.$on('pickUp', (res) => {this.isFocus = true})......

Js_Mei
41分钟前
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部