lab5 shlab（shell lab）

原创 已于 2023-08-06 10:04:31 修改
· 218 阅读 · 1 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #运维 #服务器

于 2023-08-03 15:47:50 首次发布
本文讲述了shell的工作原理，特别是eval函数如何解析命令行并创建子进程，以及如何处理SIGCHLD、SIGINT和SIGTSTP信号。文章详细解释了shell启动程序、子进程的前台与后台区分、内置命令和信号处理机制的关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考大佬

前情提要

  1. 这个实验和之前的不太一样，最好要去把书看一遍，很多具体的实验的方法，思想，甚至是代码在书上已经给出了，自己很难想出来

实验总览

  1. 总共有16个trace，运行make test0x 与 make rtest0x，比较结果是否相同
  2. 实验内容
    • eval: Main routine that parses and interprets the command line. 70 lines
    • builtin cmd: Recognizes and interprets the built-in commands: quit, fg, bg, and jobs. 25 lines
    • do bgfg: Implements the bg and fg built-in commands. 50 lines
    • waitfg: Waits for a foreground job to complete. 20 lines
    • sigchld handler: Catches SIGCHILD signals. 80 lines
    • sigint handler: Catches SIGINT (ctrl-c) signals. 15 lines
    • sigtstp handler: Catches SIGTSTP (ctrl-z) signals. 15 lines

什么是shell？

shell通常用来指命令行，我们可以通过这个命令行去启动各种程序
那么，这个命令行是如何启动这些程序的呢？

  1. shell将自己作为父进程
  2. shell创建一个子进程去启动各种程序
    那么，shell其实也就是一个进程，也不过是一个比较特殊的程序，那它这个程序是什么样的呢？
  3. 不断地循环，并打印一个提示符，我们这个lab的提示符就是这样tsh>
  4. 然后通过fgets获得我们的输入，我们的输入通常就是程序的路径（名字）以及这个程序的参数
  5. 通过我们的输入去启动程序。这里就有两种程序了，一种是前台程序，一种是后台程序
    1. 首先要明确一点，前台程序和后台程序没有本质上的区别，运行起来都是一个进程而已
    2. 前台进程比较特殊的一点就是，它会阻塞shell，一直到自己执行完了，然后让shell继续执行

eval

eval函数的功能其实类似于一个启动器

  1. 获取我们输入的各种信息
  2. 按照我们的要求去创建子进程，操作父进程

第一步，获取各种输入的信息，这个就比较简单了，因为已经提供了写好的parseline函数，我们只需要调用即可。

  // 首先根据cmdline，解析这一行命令。由于我们在解析的函数中修改了传入的cmdline，所以用了一个备份的buffer。
  // 同时解析函数的返回值其实就代表了当前这个被命令行启动的进程是前天还是后台运行的
  // 但是其实好像不备份也行，留坑！
  char buffer[MAXLINE];
  strcpy(buffer, cmdline);
  char *argv[MAXARGS];
  int is_bg = parseline(buffer, argv);
  // 题目已经定义为bg和fg，所以按照题目意思来定义状态
  int state = is_bg ? BG : FG;
  // 如果解析出来是个空的命令行，则直接return
  if (argv[0] == NULL) {
    return;
  }

第二步，就比较复杂了。
首先想一想，父进程需要做什么？

父进程

  1. 创建子进程
  2. 为子进程创建一个对应的job
  3. 根据子进程的类型决定自己是否需要阻塞，等到子进程执行完毕
    这里有两个注意点
  4. 创建子进程之前父进程需要阻塞掉SIGCHLD信号
    1. 这个信号是子进程死亡后向父进程发出的信号
    2. 为什么要阻塞这个呢？
      1. 如果刚创建好子进程，子进程就获得了cpu的使用权
      2. 然后子进程马上就执行完成，发出这个死亡的信号给父进程
      3. 父进程拿到cpu并且受到信号后就需要调用对应的处理函数，这个处理函数需要在job中删除对应项
      4. 但是因为刚创建好子进程之后父进程就没有用过cpu，父进程压根没来得及在job中为子进程创建对应项，所以这个删除操作肯定是失败的
      5. 等父进程拿到cpu之后，才给子进程注册了一个job，可是子进程早就结束了，也就是说父进程永远等不到这个子进程的死亡信号
      6. 因此这个job永远不会被删除
    3. 因此在创建子进程之后需要阻塞这个信号，再父进程完成为子进程注册job之后，就可以解除这个阻塞
  5. 操作job之前需要阻塞掉所有的信号
    1. 这个是因为jobs是一个全局变量，为了防止并发的问题，必须要阻塞掉所以的信号，包括切换进程的信号
    2. 这个有点像操作系统的各种锁的作用，保护临界资源的
      那么子进程需要干嘛呢？
  6. 首先，子进程继承了父进程的所有资源，而父进程在创建它之前已经阻塞了SIGCHLD信号量，子进程最好先将这个接触，避免可能的问题
  7. 子进程需要修改自己的组号，刚被创建时是和父进程一个组的。之所以要和父进程不同组，是为了防止子进程收到某些信号影响到同属一个组的父进程，比如对子进程发出kill命令的时候，往往是对子进程所在的组发出kill命令，如果不修改子进程组号，会把父进程也就是shell给kill了。
  8. 根据命令行的输入，使用execve函数启动对应的程序
  9. 终止

子进程这里需要注意一点，那就是用户输入的程序可能是不存在的，因此，对于execve函数的结果需要特殊处理一下

整个eval函数的实现如下，其中涉及了一些信号相关的操作比较陌生

void eval(char *cmdline) {
  // 首先根据cmdline，解析这一行命令。由于我们在解析的函数中修改了传入的cmdline，所以用了一个备份的buffer。
  // 同时解析函数的返回值其实就代表了当前这个被命令行启动的进程是前天还是后台运行的
  // 但是其实好像不备份也行，留坑！
  char buffer[MAXLINE];
  strcpy(buffer, cmdline);
  char *argv[MAXARGS];
  int is_bg = parseline(buffer, argv);
  // 题目已经定义为bg和fg，所以按照题目意思来定义状态
  int state = is_bg ? BG : FG;
  // 如果解析出来是个空的命令行，则直接return
  if (argv[0] == NULL) {
    return;
  }
  // 下面是核心操作部分
  // 创建信号集并初始化，分别是不理会所有信号，不理会一个信号（SIGCHLD），和备份之前的信号
  sigset_t all_mask, one_mask, pre_mask;
  sigfillset(&all_mask);
  sigemptyset(&one_mask);
  sigaddset(&one_mask, SIGCHLD);
  // 如果即将创建的进程不是系统程序，那下面这个函数会返回0
  // 如果是系统程序，那这个函数内部就直接执行了， 不需要我们管了
  // 因此，我们只需要处理非系统程序的情况
  pid_t pid;
  if (!builtin_cmd(argv)) {
    // 在调用fork之前就要阻塞SIGCHLD信号
    sigprocmask(SIG_BLOCK, &one_mask, &pre_mask);
    if ((pid = fork()) == 0) {
      // 子进程
      // 子进程首先解除从父进程那继承来的阻塞信号
      sigprocmask(SIG_SETMASK, &pre_mask, NULL);
      // 修改自己的组id为自己的id
      setpgid(0, 0);
      // 创建真正的进程，其中environ是在libc文件中定义的
      Execve(argv[0], argv, environ);
      // 真正的进程执行完之后，子进程也就完成使命了，使用exit终止进程，更加强劲！
      exit(0);
    }
    // 父进程继续操作
    // 首先获取全局锁，因为要修改全局变量了
    sigprocmask(SIG_BLOCK, &all_mask, NULL);
    addjob(jobs, pid, state, cmdline);
    sigprocmask(SIG_SETMASK, &one_mask, NULL);
    // 如果是前台进程，则父进程要阻塞到这个前台进程结束
    // 如果是后台进程，则父进程打印这个后台进程的信息
    if (state == FG) {
      waitfg(pid);
    } else {
      printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }
    // 父进程ok了，可以去接受SIGCHLD信号
    sigprocmask(SIG_SETMASK, &pre_mask, NULL);
  }
}

builtin_cmd

这个函数就比较简单了，用来判断用户输入的是否是内置的程序

tsh中要求的内置程序只有quit，bg，fg，jobs

这个实现没什么好说的，可能有点前置的知识那就是，argv这个变量，可以看做一个一维数组，其中

每个值都是一个字符串

  1. 第一个字符串是程序的名字
  2. 后面的每个字符串都代表了一个参数
int builtin_cmd(char **argv) {
  // 总共要处理 quit bg fg jobs，并&
  if (!strcmp(argv[0], "quit")) {
    // quit指令，直接终止
    exit(0);
  }
  if (!strcmp(argv[0], "bg") || !strcmp(argv[0], "fg")) {
    // 执行bg或者fg
    do_bgfg(argv);
    return 1;
  }
  if (!strcmp(argv[0], "jobs")) {
    // 列出jobs
    listjobs(jobs);
    return 1;
  }
  return 0;
}

do_bgfg

void do_bgfg(char **argv)

这个函数是要我们将某个job唤醒，或者由后台操作变成前台操作

  1. 首先，我们需要知道到底是要变成前台还是后台，这个参数存在argv[0]中
  2. 然后我们需要拿出具体的pid或者jid，其中jid通过%起始以做区别。
    1. 需要处理这个参数为空情况，即没有给出任何的pid或者jid。
    2. 需要处理输入的pid或者jid非法的情况
  3. 通过具体的pid或者jid拿到对应的job，如果找不到这个job，说明不存在
  4. 给这个job发出一个SIGCONT的信号，不管它之前咋样，现在都醒过来
  5. 修改这个job的状态位前台或者后台
  6. 根据前台还是后台，决定当前进程是否需要等待
void do_bgfg(char **argv) {
  // 后面要用到
  struct job_t *job = NULL;

  // 这个函数需要处理多种输入，包括一些非法输入
  // 首先是确认到底是bg操作还是fg操作
  int state = (strcmp(argv[0], "bg") == 0) ? BG : FG;

  // 然后判断是否给出了具体的pid或者jid，如果没有给出正确的参数，那要给出提示
  // 首先看看是否有参数
  if (argv[1] == NULL) {
    printf("%s command requires PID or %%jobid argument\n", argv[0]);
    return;
  }
  // 有参数，那就先看看是不是jid
  if (argv[1][0] == '%') {
    // 使用sscanf尝试获取jid
    int jid;
    if (sscanf(&argv[1][1], "%d", &jid) > 0) {
      job = getjobjid(jobs, jid);
      // 如果getjobjid返回null，则说明没有这个job
      if (job == NULL) {
        printf("%%%d: No such job\n", jid);
        return;
      }
    }
    // 到了这里，那肯定有参数，并且不是jid，但是也有可能是瞎输入的先排除一下
  } else if (!isdigit(argv[1][0])) {
    printf("%s: argument must be a PID or %%jobid\n", argv[0]);
    return;
  } else {
    // 肯定输入的是pid了
    pid_t pid;
    if (sscanf(argv[1], "%d", &pid) > 0) {
      job = getjobpid(jobs, pid);
      if (job == NULL) {
        printf("(%d): No such process\n", pid);
        return;
      }
    }
  }

  // 如果能够走到这里，那么说明已经正确取到对应的job了
  // 唤醒这个job，修改状态
  // 这里没有使用进程组，留坑！
  kill(-job->pid, SIGCONT);
  job->state = state;
  // 根据bg或者fg进行特定的操作
  if (state == BG) {
    printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
  } else {
    waitfg(job->pid);
  }
}

waitfg

void waitfg(pid_t pid)

这个函数需要做到，当pid还是前台程序的时候，调用waitfg的程序一直休眠

首先，lab已经给我们提供了一个函数fgpid去检查是否还有程序是前台程序

  1. 理论上，我们只需要不断地循环，如果发现还有程序是前台程序，那自己就sleep一下就可以了
  2. 但是这样的话，可能会很浪费时间，因为我们不知道到底要sleep多久

所以，我们最好还是使用信号的机制，书上介绍了一个很牛逼的函数sigsuspend

具体的优点书上已经详细介绍了，这里不赘述

这里就有个问题，正常来说，调用这个函数之前，进程应该是阻塞了SIGCHLD信号才对的

而我的实现里，有两处调用了这个函数，其中do_bgfg是没有阻塞上述的那个信号，但是也没有出现死锁，应该是测试数据太水了导致的

void waitfg(pid_t pid) {
  // 注意，进入这个函数的时候，父进程已经阻塞了子进程可能传来的SIGCHLD信号
  // 而我们使用的sigsuspend函数会让父进程进入一个完全没有阻塞信号的状态
  // 因此，只要有一个子进程挂了，父进程就会跳出阻塞去检查一下是否还有前台进程
  // 感觉有点问题，这里实现的好像太严格了，不只考虑了pid，还考虑所有前台进程，留坑
  sigset_t none_mask;
  sigemptyset(&none_mask);
  while (fgpid(jobs) != pid) {
    sigsuspend(&none_mask);
  }
}

sigchld_handler

这个函数和SIGCHLD信号绑定了，只要有子进程发出这个信号，父进程接收到之后就会使用这个函数去响应

  1. 首先，父进程会使用waitpid函数去看看是否有子进程挂了或者暂停
  2. 然后父进程会根据不同情况去处理
    1. 子进程正常结束：删除对应的job
    2. 子进程被信号终止：删除对应的job，并打印信息
    3. 子进程被暂停：找到对应的job，修改job的状态为暂停，并打印信息

注意点
3. WNOHANG | WUNTRACED
1. 第一个参数保证了，就算没有需要处理的子进程，当前进程也不会阻塞住不动
2. 第二个参数保证了，会去响应被暂停的子进程
4. 备份errno
5. 在修改jobs之前需要阻塞所有信号，作用和之前说的一样，防止并发带来的问题

由于我们不知道到底有多少个死亡信号或者暂停信号到达，所以必须要用while，而不是if

void sigchld_handler(int sig) {
  int olderr = errno;
  pid_t pid;
  int state;
  sigset_t all_mask, pre_mask;
  sigfillset(&all_mask);
  // 不断等待子进程，直到收到一个子进程停止的消息
  while ((pid = waitpid(-1, &state, WNOHANG | WUNTRACED)) > 0) {
    // 因为接下来需要操作jobs这个全局变量，先屏蔽所有的信号
    sigprocmask(SIG_SETMASK, &all_mask, &pre_mask);
    // 如果是正常终止，则只需要删除对应的job
    if (WIFEXITED(state)) {
      deletejob(jobs, pid);
      // 如果是被信号杀死，则还需要输出被哪个信号杀死
    } else if (WIFSIGNALED(state)) {
      deletejob(jobs, pid);
      printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid,
             WTERMSIG(state));
      // 如果是被信号暂停了，还需要修改对应job的状态
    } else if (WIFSTOPPED(state)) {
      struct job_t *job = getjobpid(jobs, pid);
      job->state = ST;
      printf("Job [%d] (%d) stoped by signal %d\n", pid2jid(pid), pid,
             WSTOPSIG(state));
    }
    sigprocmask(SIG_SETMASK, &pre_mask, NULL);
  }

  errno = olderr;
}

sigint_handler

这个函数对应于ctrl c操作，强制杀死前台的进程
实现起来很简单：找到当前的前台进程，然后通过kill函数杀死它
注意保存和恢复error

void sigint_handler(int sig) {
  // 前台进程只可能有一个，只要还存在前台进程，那就把这个前台进程给杀掉
  // 感觉这里不加信号量也没问题
  int olderr = errno;
  pid_t pid;
  if ((pid = fgpid(jobs)) != 0) {
    kill(pid, sig);
  }
  errno = olderr;
}

sigtstp_handler

这个函数对应于ctrl z函数，暂停前台进程

  int olderr = errno;
  pid_t pid;
  if ((pid = fgpid(jobs)) != 0) {
    kill(pid, sig);
  }
  errno = olderr;

留坑

  1. 至今没有搞清楚tsh运行起来之后，到底是咋实现换行的
  2. 总感觉这个做的迷迷糊糊的，没有很理解。接下来把书看一遍，希望能完全弄懂。
CSAPP深入理解计算机——shellLab（2018）
xiaolian_hust的博客
04-25 2万+
今天，我们能够跟随大佬的思路，亲自搭建自己的shell程序，虽然是阉割版，但是也能够非常激动。花了三个晚上终于完成了。再一次感谢csapp这本书，以及老师的习题和lab。废话不多说，进入正题：这次的任务十分简单清晰，直接。在做题之前请务必认真的读了实验lab的指导书，每个单词都很重要。http://csapp.cs.cmu.edu/3e/shlab.pdf总结下，我觉得其中最终的就是两点：1. 请...
CSAPP：shell lab
Lane的小屋
07-30 966
计算机系统 CSAPP
CSAPP-ShellLab
SHyyyyyy___的博客
05-19 1051
CSAPP-shellLab
CSAPP(CMU 15-213)：Lab5 Shlab详解
qq_42241839的博客
03-02 1580
# 前言 本系列文章意在记录答主学习CSAPP Lab的过程，也旨在可以帮助后人一二，欢迎大家指正！ tips:本lab主要是为了更加熟悉进程控制和信号的概念！！要完成一个支持简易作业控制的shell程序。 Shell这样的交互型程序主要负责管控用户所运行程序进程，并负责给各个子进程分配信号以完成要求！！！ handout 实现函数【参考代码行数】 所给的资料已经拥有一个shell程序的功能框架，我们只需完成有关作业控制的几个关键函数即可。（tsh.c） eval：分析和解释命令行的主例程【70行】
CSAPP LAB---shlab-handout
The_V_的博客
07-11 8242
LAB7 0x00扯淡 首先，感觉CSAPP的实验蛮好玩的，有助于我理解书上的知识，而且写一个shell应该蛮有意思的，所以还是把这试验也做了。（事实一点都不有趣！） 这个实验内容是实现一个unix下的简易shell, 需要实现的功能包括bg, fg等作业控制命令， 还需要实现ctrl-c, ctrl-z等信息的处理，由于实现这个shell需要进行多进程的编程，这是第一次进行多进程编程，
HNU计算机系统实验shlab5&shlab6
君陌的博客
11-02 2756
此为本人在进行实验时所做的实验日志，仅供参考。 1、比较trace06执行不同结果，编程实现sigint_handler捕获INT响应、waitfg()等待、sigchld_handler回收僵死： 首先在之前实验的基础上执行trace06比较不同，得到结果如下： 可以看到少了一条指令，之前的myspin都可以正常执行，于是查看trace06文件： 可以看到就是最后一条INT指令没有执行，说...
CSAPP shell lab
weixin_43876597的博客
01-29 1296
Shell中的作业（job）管理是一种用于跟踪和控制正在运行的进程的机制。Shell通常支持前台任务和后台任务，它们之间有以下差别：前台任务是由用户启动并在前台运行的任务。当你在Shell中运行一个命令，它通常会成为前台任务，并且会占用你的终端会话，直到任务完成或被中断。前台任务会接收来自终端的输入，并将其输出显示在终端上。这使得它们非常适合需要与用户交互的任务，例如编辑文本文件或运行交互式程序。要将一个正在运行的前台任务放入后台，你可以使用Ctrl+Z暂停任务，然后使用bg命令将其放入后台运行。
CSAPP Lab5：Shell
sinat_38705282的博客
11-20 885
此实验目的是为了更加熟悉进程控制和信号。该实验内容是实现一个简单的Unix Shell程序，其支持job control。准备步骤及基础要求make，编译测试程序每次修改，都需要make clean，再重新make参考 tsh.c，掌握shell 程序的架构，实现其中的空函数eval：解析命令行参数的主函数，大约70行builtin_cmd：识别内置命令，包括quit、fg、bg、jobs，大约25行do_bgfg：实现内置命令，fg和bg，大约50行。
ShellLab.zip
08-23
**ShellLab.zip** 是一个包含了计算机科学与应用（CSAPP）第六章实验——Shell Lab的详细代码和注释的压缩文件。这个实验旨在帮助学生深入理解操作系统层面的进程交互、命令解析以及脚本编程，是学习系统编程的重要...
csapp-shell-labcsapp-shell-labcsapp-shell-lab
05-03
### CS213 Fall 2002: Lab Assignment L5 - Writing Your Own Unix Shell #### Introduction In this lab assignment, the primary objective is to deepen your understanding of process control and signaling ...
CSAPP第六章实验Shell Lab代码详解
首先，“ShellLab.zip”很可能是一个压缩文件，它包含了与计算机科学教育课程相关的实验代码。CSAPP（Computer Systems: A Programmer's Perspective）是一本由Randal E. Bryant和David R. O'Hallaron编写的著名...
Shell lab CSAPP（深入理解计算机系统）
过气久远的博客
11-23 1153
系列文章目录 文章目录系列文章目录前言一、作业解释和要求Unix Shells的大致介绍二、代码0. main主程序1.eval2.builtin_cmd3. do_bgfg4.waitfg5.sigchld_handler6.sigint_handler7.sigtstp_handler总结 前言 这个lab可以说是我投入最认真的的一个。 前提是要把pdf所有的内容都熟读标注，把书上相应内容反复看几遍。按照书上的例子敲进去，在参照其他博客改改，就能基本满足lab的要求。 lab原始代码链接： http
从零开始打造 OpenSTLinux 6.6 Yocto 系统（基于STM32CubeMX）（十二）
小柯的博客
06-08 260
本文介绍了YT8511网络驱动在Linux内核中的修改方法。针对使用ST官方YT8511驱动时出现的根文件系统网络问题，需要替换两个关键文件：将motorcomm.c替换到drivers/net/phy/目录，motorcomm_phy.h替换到include/linux/目录。文档详细提供了内核重新编译的完整命令流程，包括配置合并、镜像生成、模块安装和设备树复制等步骤。最后给出了通过NFS启动的bootargs环境变量设置示例，并附带了操作过程截图。该解决方案可确保系统正常使用nfsroot启动网络功能。
Linux 中替换文件中的某个字符串
刘皇叔说Java的博客
06-06 624
或其他特殊字符，可以改用。如果你想在 Linux 中。：仅在第 5 行替换。
Linux——进程控制
2302_79306764的博客
06-09 769
用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法。一个父进程希望复制自己，使父子进程同时执行不同的代码段。之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。最后，父进程派给子进程的任务完成的如何，我们需要知道。父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息。
Linux nano命令的基本使用
菜鸟记录
06-08 863
⏹Linux nano命令的基本使用
Linux 任务调度策略
最新发布
休息一下接着来的博客
06-11 447
Linux内核提供了三种主要调度策略：SCHED_FIFO（先进先出实时调度）、SCHED_RR（轮转实时调度）和SCHED_OTHER（基于CFS的非实时调度）。SCHED_FIFO适用于硬实时任务，无时间片限制；SCHED_RR采用时间片轮转，兼顾实时性和公平性；SCHED_OTHER通过vruntime机制实现公平调度。实时调度策略需要root权限，优先级1-99，而非实时策略使用nice值调整优先级。选择策略需权衡实时性、公平性和风险，如SCHED_FIFO可能导致低优先级任务饿死，而SCHED_O
Linux【3】-----系统框架概述
m0_46451722的博客
06-07 399
linux一定需要挂载操作系统一切皆文件。
archlinux中使用 Emoji 字体
lxyoucan的博客
06-07 265
在 Arch Linux 中，若你想正确显示如 🔊 这类 Emoji 图标或Unicode 符号字体，需要安装支持这些符号的字体包。下面是推荐安装的字体包及说明：noto-fonts-emoji（Google 的 Emoji 字体）
shlab-handout
12-22
shlab-handout 是由 Shanghai Lab for Life Sciences (SHL) 提供的一份信息手册。SHL 是一个以生命科学为主题的研究实验室，旨在推动生命科学领域的研究和发展。shlab-handout 提供了SHL 实验室的相关信息，包括实验室的介绍、研究领域、设备设施、项目合作等内容。 shlab-handout 的内容丰富全面，通过手册可以了解SHL 实验室的研究重点和实力，可以帮助外部合作伙伴更好地了解SHL 实验室的专业领域和优势。此外，shlab-handout 也可以帮助潜在的学生、研究人员或合作伙伴更好地了解SHL 实验室的学术氛围和合作机会，从而更好地拓展个人或团队的研究合作空间。 总之，shlab-handout 是一份有益的信息手册，通过对SHL 实验室的介绍和展示，可以更好地促进学术交流和合作，推动生命科学领域的研究和发展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值