1. “Interactive” 什么是可交互的。

人们是怎么和程序交互的？

咱们会经过GUI来运用咱们的操作体系，GUI即图形用户界面，它愈加地友爱、易用，极大程度上地降低了运用核算机的学习成本和扩展了家用核算机的用处，运用GUI，离不开的便是一些外设，例如：鼠标（触摸板）、键盘、触摸屏等等。它们承担着用户对核算机操作的输入，而音响、显示器则承担着输出，这一来一往便是“交互”，这个交互的前提，便是咱们的用户界面：GUI。

时光倒流，咱们先抛开GUI这么个现代的产品，回到只要字符终端的时代。咱们和程序、核算机交互的唯一办法，便是运用键盘输入字符，然后在显示字符的显示器上输出内容。例如经过键盘输入到终端，然后经过终端打印运转的成果。在那个时代，交互好像没有那么多、那么麻烦的问题要处理，咱们只需求add 1 2，1和2就会被传入到程序的main函数的参数中，咱们就能够运用add这么个程序去核算1+2的值，然后输出3这个成果，这也是可交互的。1、2，便是咱们的输入，3便是输出，这便是一次交互。

可是一般来说，3输出之后，main函数回来，程序就结束了，这种程序并不是能够持续交互的，由于它只能读入一次输入，做出一次输出，假如想多次运用，你就得启动多次程序的实例。

人们想到，从标准输入流读入字符，然后用一个while循环，等等标准输入流来接纳指令，依据输入的字符来做出反应，这也便是咱们的Shell的运转办法：

string cmd;
while(true){
     cmd = readLine()
     // 获取参数的第一个内容，例如add 1 2 获取的便是add字符
     switch(command.firstArg()){
      case "cd"->switch_work_dir();// 切换作业目录
      case "exit"->exit();// 退出shell
      case "add" -> add(cmd);// 假定shell有这么个内置指令，用来核算第一个参数和第二个参数相加的，实际上是没有的
      ……
      else -> print_err();// 没有这个指令
    }
}
void add(string cmd){
   val arg1 = getArg(cmd);
   val arg2 = getArg(cmd);
   print(arg1 + arg2);
}

这样一来，程序就变得能够持续交互了，假如咱们想多次履行add指令，只需求在终端中，输入add 1 2即可进行一次核算，完结后程序会回到cmd = readLine()这么一行堵塞， 然后一旦标准输入流中有了输入，此处就被唤醒，持续履行用户的输入，这便是一个很简单的可交互程序。

所以，一个程序可交互的要害之处，就在于：

  • 等候用户输入；
  • 由输入的工作决议下一步的操作；
  • 持续等候用户输入。

由此就构成了一个闭环，循环不退出，程序也不退出；循环退出了，程序也退出了。

[注]

  1. 一般来说，有一些指令是内置在Shell中的，cd是一个，由于cd用于切换程序的作业目录，同理pwd也是内置指令，exit也是一个，用于退出当前的Shell。而其它的例如ls、top、cat是这些都是独立的程序，你能够运用where分辨一个指令究竟是Shell built-in command仍是独立的一个运用程序。

2. 看一看Shell的完结

2.1 Shell和终端

GUI咱们天天在运用自然不必多说，Android、Mac便是一个支撑GUI的操作体系，可是不代表它只能运转GUI运用，咱们能够经过类似SSH等办法登录到操作体系之上运用，这样便是在非GUI环境下运用操作体系了。

而此处的终端一般指的是模仿终端，用来模仿有一个用户现在连接到该核算机，在Mac或许Ubuntu上终端一般以Terminal软件的方式存在：

Android消息机制（一）程序与交互

终端只会进行模仿用户的输入和输出，由于现在这一类的发行版操作体系基本上都是以GUI交互为主了，所以模仿终端能够看做是一个指令行的模仿东西和交互的进口。

而Shell则是一个跑在远程机器上的一个运用程序，它的效果是解析用户输入、运转程序、得到用户输出最后回来给模仿终端，Shell一般指的是一类程序，例如咱们常用的bash、zsh都是一个Shell，即用户指令解析东西。

Shell所做的工作，便是在源源不断地解析用户输入，然后处理用户指令，调用对应的程序、操作，然后持续等候用户指令，它便是最早的可持续交互运用程序之一。

2.2 Xv6 Shell.c的完结

Xv6是由麻省理工学院(MIT)为操作体系工程的课程（代号6.828）,开发的一个教育意图的操作体系。Xv6是在x86处理器上(x即指x86)用ANSI标准C从头完结的Unix第六版(Unix V6，一般直接被称为V6)。

int
main(void)
{
  static char buf[100];
  int fd;
 // 确保只翻开012三个流，其他的流全部封闭掉
  while((fd = open("console", O_RDWR)) >= 0){
    if(fd >= 3){
      close(fd);
      break;
    }
  }
  // Read and run input commands.
  while(getcmd(buf, sizeof(buf)) >= 0){
    if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
      // Clumsy but will have to do for now.
      // Chdir has no effect on the parent if run in the child.
      buf[strlen(buf)-1] = 0;  // chop \n
      if(chdir(buf+3) < 0)
        printf(2, "cannot cd %s\n", buf+3);
      continue;
    }
    if(fork1() == 0)
      runcmd(parsecmd(buf));
    wait();
  }
  exit();
}

由于Xv6是用于教育的Unix操作体系，所以全体代码十分干净，也很适合阅览，它的Shell的完结，首先是测验翻开了一个console，第一部分的代码主要是确保：fd = 0、1、2的三个标准流被翻开，这三个流终究都指向了console，也便是操控终端，分别是输入、输出和过错流。

尔后，第二部分的代码会不断地从标准输入流中读取输入，存在buf中，然后去解析指令。例如cd指令便是在这里解析的，然后调用chdir来修正当前的作业目录。由于没有其他指令了，就去调用fork去创建一个子进程，并且在子进程中，先解析指令，然后去运转新的程序（假如指令正确的话）。而父进程则调用wait等候它的履行，此刻Shell就被挂起，然后处理器去履行fork出来的子进程，子进程履行完结后，再接着回来履行Shell的循环。

这便是一个实在的、可用的，交互程序的完结，咱们能够看看getcmd是怎么完结的。在Xv6中，getcmd会调用到read这个体系调用，对应的体系调用是sys_read，调用号是5，终究函数会走向file.c中的fileread函数中：

// Read from file f.
int
fileread(struct file *f, char *addr, int n)
{
  int r;
  if(f->readable == 0)
    return -1;
  if(f->type == FD_PIPE)
 return piperead(f->pipe, addr, n);
 if (f->type == FD_INODE){
   ilock(f->ip);
 if ((r = readi(f->ip, addr, f->off, n)) > 0 )
f->off += r;
iunlock(f->ip);
    return r;
  }
  panic("fileread");
}

依据文件类型的不同，读取的办法也不同，首先是管道，读取调用的是piperead办法；然后是一般文件，运用的是先调用ilock办法，测验给iNode加锁，锁上了之后在调用readi去读文件，但不论是pipe仍是inode，终究都离不开一个东西：循环，循环到文件可用的时分或许是读出新数据的时分，跳出循环即可读取数据，然后唤醒等候的程序：

int
piperead(struct pipe *p, char *addr, int n)
{
  // ……
  while(p->nread == p->nwrite && p->writeopen){  //DOC: pipe-empty
    // ……
    sleep(&p->nread, &p->lock); //DOC: piperead-sleep
  }
  // ……
  wakeup
}
void
ilock(struct inode *ip)
{
  // ……
  while(ip->flags & I_BUSY){
    sleep(ip, &icache.lock);
  }
  // ……
  wakeup
}

sleep的效果便是让程序进入sleep，并调用sched()，从头进入调度，终究会走向一段汇编代码，咱们看看注释：

# Save current register context in old
# and then load register context from new.
便是进程的上下文切换。

这便是getscmd时，程序的堵塞，无非便是调用getscmd -> 体系调用读 -> 有内容则回来，没有内容则堵塞，堵塞的实质是一个循环，循环内部不断地去自旋，然后内部调用sched去调度来释放CPU（进程的上下文的切换）。

  1. 你也不必忧虑程序假如不去调用sched会发生什么，由于这些都是read体系调用的代码，都是体系内置的。只要你调用了read就会遭到操作体系read完结办法的约束，并不会由于外部的调用而导致原有的内部完结出现问题。
  2. 这也只是Xv6的处理办法，其他的操作体系一般会运用堵塞行列 + 中止来处理读取堵塞，比方Android便选用了epoll机制，当堵塞发生的时分，程序进入堵塞行列，处理机调度给其它程序，然后等候IO，IO完结后，就会发生中止告诉CPU，激活堵塞行列找到你的进程，然后从头移入就绪态进行调度履行。

3. 繁忙的主线程

咱们能够运用C言语直接写一个程序，模仿Shell的方式让他能够交互起来，然后启动一个线程去下载文件，一般来说，子线程鄙人载文件，并不会影响到主线程的履行，程序的主线程仍然能够接受指令和解析指令，可是异步使命完结后，咱们必定需求某种机制去告诉主线程。一般是在循环中，检查一下是否有音讯：

string cmd;
result = null;
void download(url){
  // 下载
  result = download(url);
}
while(true){
     cmd = readLine()
     if(result != null){
         // 处理音讯
         result.处理();
         ......
         // 处理完结后进入下一次循环
         result = null;
         continue;
     }
     // ……
    }
}

然后告知用户下载成果。假如只要一个异步使命咱们能够用一个变量，可是假如有多个使命咱们可能就得考虑运用一个数组或许链表来存储对应的成果了：

result = [];
onSuccess((){
  result.add(true);
});

而GUI面临的问题，却愈加杂乱。

由于GUI对主线程的工作输入来历将愈加广泛，以Android为例，例如上述提到的异步使命的成果，咱们需求提交给主线程来做视图更新；又例如咱们的视图更新本身，也要在主线程履行，只不过它有很高的优先级；触摸、滑动、点按工作也需求也主线程统一下发履行，包含页面跳转、一些生命周期函数的履行等等，都需求主线程来履行。

3.1 音讯行列

假如没有一个专门的结构来存储这一系列需求主线程履行的信息和操作，那么面临猝发的一系列的音讯，主线程必然是分身乏术，所以音讯行列应运而生。

由于主线程在一个时间只能处理一条音讯，比方烘托画面，比方下发工作，比方处理异步工作的成果等等，它并不能同时处理，所以，这些音讯就依照「先后 + 重要性」次序顺次排开，在一个行列中，主线程不断地从行列中去取音讯来履行，这样做到了微观上主线程能够处理多个音讯的「假象」。相同地，这也便是意味着简直任何音讯的都是有延迟的，比方此刻主线程真实处理一个异步网络的回调：

val result =  download(url);
callback(result);// 预计耗时100ms

假如此刻有一个Vsync信号进来，告诉去烘托视图，可是这个烘托信号必须等到这个异步网络回调处理完结之后，才有可能在循环中被取出，从而得到履行，这样一来100ms之内的约6个帧就无法被烘托出来，导致视图停留在当前状态6×16.6ms 至少100ms，这会形成卡顿；假如再严要点，延迟了数秒，Android体系甚至会抛出一个未呼应。这也是不主张在主线程进行耗时核算的原因。

由于工作之间有轻重缓急，所以所有的工作也不是依照参加的次序履行的，烘托这类的、用户具有高可感知性的使命一般会确保优先履行；而其他的使命则能够稍等。而使命一旦开始履行是无法被中止的，这就需求一个调度的机遇。

聪明的你必定想到了，这个机遇必定在循环傍边，只要咱们去读取音讯的时分，主线程才知道是否有紧急使命、是否去优先调度紧急使命，其他时间主线程简直都在各种各样的Message的Runnable或许Message预置的一些操作中不停地做操作。

在Android中，可切换的粒度便是一个音讯，仅当一个音讯Runnable和音讯对应的工作履行完结之后，才有可能让下一个紧急的使命履行，并不会发生网络回调履行了一半，就被紧急工作视图烘托中止的情况；可是假如此刻别的一个网络回调的使命排在行列的最前端，此刻又有一个烘托使命被参加行列，那么就会优先履行更为紧急的烘托使命，详细的完结咱们后面再谈。

4. 小结

以上便是咱们运用指令和核算机交互的一个简单过程，总结下来，咱们离不开的几个点，便是：

  1. main函数
  2. 等候用户输入
  3. 依据用户输入，履行下一步操作
  4. 持续等候用户输入

不难发现，2到4，4再到2构成了一个「循环」，这个循环，便是程序可持续交互的要害。

相同，咱们也了解了主线程在用户交互中重要的地位，特别是在GUI中，主线程要『同时』处理许多的使命，以Android为例，首战之地的便是频频的视图更新，假如UI不断地在变化，那么16.6ms（60帧）就会发生一个Vsync信号来更新视图。

这些使命并不能放到子线程中履行，由于视图的更新是十分频频的，假如选用铺开多线程更新视图，假如不做同步处理，那么可能会由于运用不标准导致制作的问题；假如做了同步处理，势必又会由于锁导致性能的下降。

然后咱们介绍了音讯行列，那么音讯行列解决了什么问题呢？归根到底，线程在一个时间只能在履行一个操作，而由于源源不断的工作来历，可能会让咱们现有的程序履行流在面临各种各样工作的时分分身乏术。借助于Java/Kotlin言语的特性，函数能够以一个Runnable或许一个Lambda表达式的方式存在，而每个函数，便是线程履行的一个单元， 只要在一个履行单元完结之后，才可能去履行其他单元的程序，音讯行列便是存储这类履行流的结构，他便是确保Android App可持续交互的“功臣”。

~end