面试杭州某科技公司 日期：2023.04.19

那链表和数组它的区别主要是什么？

它们的主要区别在于数据的存储方式和访问方式。

数组是一种线性数据结构，它将元素存储在连续的内存空间中，每个元素可以通过其下标来访问。由于元素在内存中的位置是连续的，因此可以通过下标快速访问数组中的元素。数组在声明时需要指定长度，因此在使用过程中无法动态地改变数组的大小。

链表是一种非线性数据结构，它通过将元素存储在节点中，并使用指针将这些节点连接起来。每个节点包含一个数据元素和一个指向下一个节点的指针。由于节点在内存中的位置可以是任意的，因此链表可以动态地添加和删除元素。但是，由于访问链表中的元素需要从头节点开始遍历整个链表，因此访问链表中的元素比访问数组中的元素更慢。

综上所述，数组适用于需要频繁访问元素的场景，而链表适用于需要频繁插入和删除元素的场景。当需要同时兼顾访问和插入/删除的效率时，可以使用其他数据结构，如树、堆、哈希表等。

假如我有一个单向链表，那我要获取这个单向链表的倒数第 n 个元素，我要怎么去获取到？

要获取单向链表的倒数第 n 个元素，可以使用双指针的方法。首先定义两个指针 p 和 q，初始时都指向链表的头节点。然后将指针 q 向前移动 n-1 步，使得指针 p 和 q 之间相隔 n-1 个节点。接下来，同时移动指针 p 和 q，直到指针 q 指向链表的末尾，此时指针 p 指向的节点就是倒数第 n 个节点。

具体步骤如下：

1. 定义两个指针 p 和 q，初始时都指向链表的头节点。
2. 将指针 q 向前移动 n-1 步，使得指针 p 和 q 之间相隔 n-1 个节点。
3. 同时移动指针 p 和 q，直到指针 q 指向链表的末尾。
4. 此时指针 p 指向的节点就是倒数第 n 个节点。

需要注意的是，在实际应用中，还需要对链表的长度和 n 的大小进行判断，确保链表中至少有 n 个节点，并且 n 的值不超过链表的长度，否则可能会出现指针越界的情况。

Linux有一个文件的权限是751，那这个权限 751 是什么意思？

第一位表示类型 后面9位表示权限，用八进制表示法表示的。
在 Linux 中，每个文件和目录都有一个所有者和一个用户组,数字代表含义如下：

- 0：没有权限
- 1：执行权限
- 2：写权限
- 3：写和执行权限
- 4：读权限
- 5：读和执行权限
- 6：读和写权限
- 7：读、写和执行权限
在数字表示法中，第一位表示所有者的权限，第二位表示用户组的权限，第三位表示其他用户的权限。

在 751 权限中，第一位 7 表示所有者有读、写和执行权限（4+2+1=7），第二位 5 表示用户组只有读和执行权限（4+1=5），第三位 1 表示其他用户只有执行权限（1）。因此，这个文件或目录的权限是：所有者可以读、写和执行，用户组可以读和执行，其他用户只能执行。

总的来说，751 权限表示这个文件或目录的所有者有最高权限，用户组和其他用户的权限相对较低，只能读取和执行，不能修改或写入。

假如我在阿里云上买了一台服务器ECS，对吧？然后我要把我本地的一个二进制上传到我的这个 ECS 上，我要有哪些实现方式？

在阿里云上购买了一台 ECS 后，需要将本地的二进制文件上传到 ECS 上，有以下几种实现方式：

1. 使用 scp 命令：使用 scp 命令可以将本地文件上传到 ECS 上。示例命令为：

   scp /path/to/local/file user@ecs-ip:/path/to/remote/file
   ```
   
   其中，`/path/to/local/file` 为本地文件路径，`user` 为 ECS 上的用户名，`ecs-ip` 为 ECS 的 IP 地址，`/path/to/remote/file` 为 ECS 上文件的路径。
   
   

2. 使用 sftp 命令：使用 sftp 命令可以建立一个安全的 FTP 连接，将本地文件上传到 ECS 上。示例命令为：

   sftp user@ecs-ip
   put /path/to/local/file /path/to/remote/file
   ```
   
   其中，`user` 和 `ecs-ip` 分别为 ECS 的用户名和 IP 地址，`/path/to/local/file` 为本地文件路径，`/path/to/remote/file` 为 ECS 上文件的路径。
   
   

3. 使用 ftp 命令：使用 ftp 命令可以将本地文件上传到 ECS 上。首先需要在 ECS 上安装 ftp 服务，然后在本地使用 ftp 命令连接 ECS，将文件上传到 ECS 上。示例命令为：

   ftp ecs-ip
   user ftp-username ftp-password
   put /path/to/local/file /path/to/remote/file
   ```
   
   其中，`ecs-ip` 为 ECS 的 IP 地址，`ftp-username` 和 `ftp-password` 分别为 ECS 上 ftp 服务的用户名和密码，`/path/to/local/file` 为本地文件路径，`/path/to/remote/file` 为 ECS 上文件的路径。
   
   

4. 使用云存储服务：阿里云提供了云存储服务 OSS，可以将文件上传到 OSS 上，然后通过 ECS 访问 OSS 上的文件。具体步骤为：在阿里云控制台创建 OSS 存储空间，使用 ossutil 工具上传文件到 OSS 上，然后在 ECS 上安装 ossfs 工具挂载 OSS 存储空间，就可以访问 OSS 上的文件了。

以上是几种常见的将本地文件上传到阿里云 ECS 的方式，根据实际情况选择合适的方式即可。

假如我在服务器上有一个端口被占用了，那我怎么找到哪个进程占用我的这个端口啊？

在 Linux 中，可以使用 lsof 命令来查找占用指定端口的进程。lsof 是 "list open files" 的缩写，可以列出系统中打开的文件和网络连接等信息。

具体操作步骤如下：

1. 打开终端，以超级用户（root）身份运行以下命令，以查找占用端口 8080 的进程：

   sudo lsof -i :8080
   ```
   
   上述命令中，`-i` 参数表示查找网络连接信息，`8080` 表示要查找的端口号。
   
   

2. 运行上述命令后，lsof 将列出占用指定端口的进程信息，包括进程 ID（PID）、进程名称、用户、文件描述符等等。例如：

   COMMAND  PID    USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
   nginx   1234   root   10u  IPv4  123456      0t0  TCP *:8080 (LISTEN)
   ```
   
   上述输出中，`COMMAND` 表示进程名称，`PID` 表示进程 ID，`USER` 表示进程所属用户，`FD` 表示文件描述符，`TYPE` 表示连接类型（TCP 或 UDP），`DEVICE` 表示连接所在设备，`SIZE/OFF` 表示连接的大小或偏移量，`NODE` 表示连接所在节点，`NAME` 表示连接名称（IP 地址和端口号）。
   

通过上述命令，我们可以找到占用指定端口的进程，以便进一步进行处理。如果需要关闭占用端口的进程，可以使用 kill 命令，例如：

sudo kill -9 PID

其中 PID 表示要关闭的进程的进程 ID。但是需要注意的是，强制关闭进程可能会导致数据丢失或其他问题，因此应该谨慎使用。

假如我找Linux某一个进程，我要怎么去找？

在 Linux 中，有多种方式可以查找指定的进程，以下是其中的几种常用方法：

1. ps 命令：ps 命令可以列出当前系统中正在运行的进程信息，可以使用以下命令来查找指定的进程：

   ps -ef | grep 进程名称
   ```
   
   上述命令中，`-ef` 参数表示列出所有进程信息，`grep` 命令用于查找进程名称。
   
   

2. top 命令：top 命令可以实时显示系统中正在运行的进程信息，可以使用以下命令来查找指定的进程：

   top -u 用户名
   ```
   
   上述命令中，`-u` 参数表示按照指定的用户名列出进程信息。
   
   

3. htop 命令：htop 命令是 top 命令的增强版，可以以交互式的方式显示系统中正在运行的进程信息，可以使用以下命令来查找指定的进程：

   htop
   ```
   
   运行 `htop` 后，可以使用键盘上的方向键、回车键等进行交互式操作，例如可以按下 `F4` 键来输入过滤条件，然后输入进程名称来查找指定的进程。
   
   

4. pgrep 命令：pgrep 命令可以根据进程名称或其他条件来查找进程 ID，例如：

   pgrep 进程名称
   ```
   
   上述命令将返回所有名称为 `进程名称` 的进程 ID。
   

无论使用哪种方法，都可以通过查找进程名称或其他条件来定位指定的进程。如果需要对进程进行操作，可以使用 kill 命令来关闭进程，例如：

kill 进程ID

其中 进程ID 表示要关闭的进程的进程 ID。如果需要强制关闭进程，可以使用 kill -9 进程ID 命令。

那怎么能看到我当前机器的一个运行情况？比如说我 CPU 占了多少内存占了多少这些负载情况。

在 Linux 中，有多种方式可以查看系统的运行情况，以下是其中的几种常用方法：

1. top 命令：top 命令可以实时显示系统中正在运行的进程信息和系统负载情况，包括 CPU 占用率、内存使用情况、进程数量等等。可以直接在终端运行 top 命令，然后按下 q 键退出。

2. htop 命令：htop 命令是 top 命令的增强版，可以以交互式的方式显示系统负载情况和进程信息。可以在终端中运行 htop 命令，然后使用键盘上的方向键、回车键等进行交互式操作。例如可以按下 F2 键来进入设置页面，然后按下 F4 键来输入过滤条件，只显示符合条件的进程。

3. uptime 命令：uptime 命令可以显示系统的运行时间、平均负载等信息。可以在终端中直接运行 uptime 命令，例如：

   $ uptime
   14:20:01 up 1 day,  3:45,  2 users,  load average: 0.00, 0.02, 0.05
   ```
   
   上述输出中，`load average` 表示系统的平均负载情况，分别表示过去 1 分钟、5 分钟、15 分钟的平均负载。如果平均负载过高，说明系统的资源使用已经接近饱和，可能需要优化系统配置或增加硬件资源。
   
   

4. free 命令：free 命令可以显示系统的内存使用情况。可以在终端中直接运行 free 命令，例如：

   $ free -h
                 total        used        free      shared  buff/cache   available
   Mem:           7.7G        2.1G        1.7G        187M        3.8G        5.0G
   Swap:            0B          0B          0B
   

   上述输出中，Mem 表示物理内存的使用情况，Swap 表示交换空间（虚拟内存）的使用情况。可以通过这些信息来判断系统的内存使用情况，如果物理内存使用过高，可能需要优化程序或增加内存资源。

通过上述命令，可以实时了解系统的运行情况，有助于快速定位系统问题并作出优化和调整。

我实时的看Linux哪个进程占了占的 CPU 最多？怎么去查找出来？

在 Linux 中，有多种方式可以实时查看哪个进程占用了最多的 CPU 资源，以下是其中的几种常用方法：

1. top 命令：top 命令可以实时显示系统中正在运行的进程信息和系统负载情况，包括 CPU 占用率、内存使用情况、进程数量等等。在 top 命令的输出结果中，按下 Shift + P 键，将按照 CPU 使用率对进程进行排序，CPU 使用率最高的进程将会出现在列表的顶部。

2. htop 命令：htop 命令是 top 命令的增强版，可以以交互式的方式显示系统负载情况和进程信息。在 htop 命令的输出结果中，按下 F6 键，然后选择 PERCENT_CPU，将按照 CPU 使用率对进程进行排序，CPU 使用率最高的进程将会出现在列表的顶部。

3. ps 命令：ps 命令可以列出当前系统中正在运行的进程信息。可以使用以下命令来查找 CPU 使用率最高的进程：

   ps aux --sort=-%cpu | head
   ````
   
   上述命令中，`aux` 参数表示列出所有进程信息，`--sort=-%cpu` 参数表示按照 CPU 使用率进行倒序排序，`head` 命令用于只显示前面几行结果，可以根据需要自行设置。
   
   

4. pidstat 命令：pidstat 命令可以实时查看指定进程的 CPU 使用情况。可以使用以下命令来查看指定进程的 CPU 使用率：

   pidstat -p 进程ID 1
   ````
   
   上述命令中，`-p` 参数表示指定要查看的进程 ID，`1` 表示每隔 1 秒更新一次结果。可以通过观察输出结果来了解指定进程的 CPU 使用情况。
   

通过上述命令，可以实时了解哪个进程占用了最多的 CPU 资源，有助于快速定位系统问题并作出优化和调整。

vi 跟 vim 有什么区别吗？

vi 和 vim 都是常见的文本编辑器，它们的主要区别在于功能和使用体验上：

1. 功能上的区别：vim 是 vi 的增强版，提供了更多的功能和命令，如多级撤销、语法高亮、分屏编辑等。相对于 vi，vim 更加适合程序员和开发人员使用。

2. 使用体验上的区别：vi 和 vim 在界面和快捷键上存在一些差异。在 vi 中，需要通过 ESC 键切换到命令模式，然后才能进行编辑、保存等操作。而在 vim 中，可以直接在插入模式和命令模式之间进行切换，快捷键也更加丰富和灵活。

因此，对于熟悉 Linux 系统的用户来说，vi 可能更加便捷，而对于需要更高级功能的用户，或者需要在编辑时进行语法高亮等操作的用户，vim 可能更加合适。不过需要注意的是，vi 和 vim 的基本用法和命令是相同的，因此对于初学者来说，先掌握 vi 的基本用法，再逐渐学习 vim 的高级功能也是很有帮助的。

vi 或者 vim 在想搜索一个文档里面的某个关键词，怎么去搜索？

在 vi 或者 vim 中搜索文档中的某个关键词，可以使用以下命令：

1. 进入命令模式：在编辑器中按下 ESC 键，即可进入命令模式。

2. 输入搜索命令：在命令模式下输入 /，然后输入要搜索的关键词，按下回车键。

3. 查看搜索结果：编辑器会自动跳转到第一个匹配的结果处，可以使用 n 命令跳转到下一个匹配结果，使用 N 命令跳转到上一个匹配结果。

例如，要在当前文档中搜索关键词 example，可以按照以下步骤操作：

1. 按下 ESC 键进入命令模式。

2. 输入 /example，按下回车键。

3. 查看搜索结果，并使用 n 命令跳转到下一个匹配结果。

需要注意的是，在 vim 中，可以通过配置来开启搜索结果的高亮显示，使得搜索结果更加直观和易于查看。可以在 ~/.vimrc 文件中添加以下命令来开启搜索结果的高亮显示：

set hlsearch

这样，在搜索时匹配的结果会被高亮显示出来。

能简单说一下 TCP 跟 UDP 的一个区别吗？

TCP（Transmission Control Protocol，传输控制协议）和 UDP（User Datagram Protocol，用户数据报协议）是常见的两种网络传输协议，主要区别如下：

1. 连接方式：TCP 是面向连接的协议，需要在数据传输前先建立连接。而 UDP 是无连接的协议，数据传输前不需要建立连接。

2. 可靠性：TCP 提供可靠的数据传输，能够保证数据的完整性和有序性，并且会自动重传丢失的数据包。而 UDP 则不提供可靠性保证，可能会出现数据包丢失、重复、乱序等问题。

3. 传输效率：由于 TCP 在传输过程中需要进行连接管理、数据确认、重传等操作，因此相对于 UDP 来说传输效率较低。而 UDP 则不需要进行这些操作，传输效率较高。

4. 应用场景：由于 TCP 提供可靠的数据传输，适用于对数据传输可靠性要求较高的应用场景，如文件传输、电子邮件等。而 UDP 则适用于数据传输效率要求较高、允许部分数据丢失的应用场景，如视频、音频等。

因此，在选择 TCP 或者 UDP 作为网络传输协议时，需要根据具体应用场景的需求来进行选择。如果需要可靠的数据传输，应该选择 TCP；如果需要高效的数据传输，并且可以允许部分数据丢失，可以选择 UDP。

服务是怎么暴露到公网的？就是暴露到外部，供外部访问的。

使用 Docker 部署 Vue 项目，一般需要进行以下步骤：

1. 编写 Dockerfile：Dockerfile 是用来构建 Docker 镜像的文件，可以在其中定义镜像的基础环境、依赖库、应用程序等信息。可以在项目根目录创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方的 Node.js 镜像作为基础镜像
FROM node:14.17.5

# 创建一个工作目录，并将当前目录下的所有文件拷贝到工作目录中
WORKDIR /app
COPY . .

# 安装依赖
RUN npm install

# 构建项目
RUN npm run build

# 将构建好的文件复制到 Nginx 的默认目录中
RUN cp -r dist/* /usr/share/nginx/html

# 暴露 80 端口
EXPOSE 80

# 启动 Nginx 服务
CMD ["nginx", "-g", "daemon off;"]

在上面的 Dockerfile 中，首先使用官方 Node.js 镜像作为基础镜像，然后将当前目录下的所有文件拷贝到工作目录中，并安装依赖、构建项目。最后将构建好的文件复制到 Nginx 的默认目录中，并暴露 80 端口，启动 Nginx 服务。

2. 构建 Docker 镜像：使用以下命令在项目根目录中构建 Docker 镜像：

docker build -t your_image_name .

其中，your_image_name 是自定义的镜像名称，. 表示当前目录。

3. 运行 Docker 容器：使用以下命令在 Docker 中运行容器：

docker run -d -p 80:80 your_image_name

其中，-d 表示以后台模式运行容器，-p 80:80 表示将主机的 80 端口映射到容器的 80 端口，your_image_name 是上一步构建的镜像名称。

4. 访问 Vue 应用：在浏览器中访问 http://localhost，即可访问 Vue 应用。

需要注意的是，在使用 Docker 部署时，需要确保 Docker 已经正确安装，并且已经启动 Docker 服务。另外，在部署过程中，还需要进行一定的安全性配置和加固，如限制容器的资源使用、配置容器的网络访问等。

假如我数据库一张表里面对 name 用户的名称， sex 用户的性别， age 用户的年龄，三个字段。然后我要查询男生和女生的平均年龄和最大年龄，怎么查？

可以使用 SQL 中的 GROUP BY 和聚合函数来查询男生和女生的平均年龄和最大年龄。具体的 SQL 查询语句如下：

SELECT sex, AVG(age) AS avg_age, MAX(age) AS max_age
FROM your_table_name
WHERE sex IN ('男', '女')
GROUP BY sex;

其中，your_table_name 是表名，sex、age 是列名，IN 关键字用于指定查询男生和女生，AVG 和 MAX 分别是聚合函数，用于计算平均年龄和最大年龄。GROUP BY 关键字用于按照性别分组，最后得到的结果是一个包含性别、平均年龄和最大年龄的表格。

需要注意的是，在查询过程中，需要确保表中的数据类型正确，如 age 列应该是数值型，sex 列应该是字符型。另外，如果表中存在空值，可以使用 IFNULL 函数或者 COALESCE 函数来处理空值。例如，将空值替换为 0 年：

SELECT sex, AVG(IFNULL(age, 0)) AS avg_age, MAX(IFNULL(age, 0)) AS max_age
FROM your_table_name
WHERE sex IN ('男', '女')
GROUP BY sex;

假如我有一张表，对吧？它有 100 行数据，我要查询第 20 行到第 25 行数据，一个简单的分页能写出来吗？。

可以使用 SQL 中的 LIMIT 和 OFFSET 关键字来实现简单的分页查询。具体的 SQL 查询语句如下：

SELECT *
FROM your_table_name
LIMIT 5 OFFSET 19;

其中，your_table_name 是表名，LIMIT 关键字用于指定返回的行数，OFFSET 关键字用于指定从第几行开始返回数据。在上述查询语句中，返回的是第 20 行到第 25 行的数据，即返回 5 行数据，从第 20 行开始返回。

需要注意的是，在实际的应用中，分页查询还需要考虑数据总量、当前页数、每页返回的行数等因素，以保证查询结果的正确性和可用性。此外，如果表中存在大量数据，分页查询可能会对数据库的性能产生影响，需要进行优化和调整。

Golang 里面的 defer 的作用是什么？

defer 的作用它主要是在一个，比如说它就是类似于这个栈的后进先出的这种执行，然后就是在一个函数它 return 之后，在结束之前去才去执行这个地方。

我们一般在这个 defer 函数里面做哪些操作？

嗯，一般这个 differ 的话可以用来是这个关闭一些系统资源，或者断开一些链接，或者是新建一个链接。对，这种。

Golang里面Map是一个并发安全的数据结构。

在 Go 语言中，map 是一种非并发安全的数据结构，不适合在并发环境中使用。如果多个 goroutine 并发地读写同一个 map，可能会导致数据竞争和并发安全问题。

为了解决这个问题，可以使用 Go 语言提供的并发安全的 sync.Map 类型。sync.Map 是 Go 语言标准库中提供的一种并发安全的 map 类型，支持多个 goroutine 并发地读写，不需要额外的锁机制。

sync.Map 的使用方法和普通的 map 类型类似，可以使用 Load、Store、Delete 等方法进行读写操作。具体的使用方法可以参考 Go 语言官方文档的说明：golang.org/pkg/sync/#M…

需要注意的是，sync.Map 的性能可能会比普通的 map 类型略低，因为它需要进行额外的并发安全处理。在实际使用时，需要根据具体的应用场景和性能需求进行选择和权衡。

能简单的说一下 Golang 里面的 init 函数吗？

在 Go 语言中，init 函数是一种特殊的函数，用于程序的初始化操作。每个包可以包含一个或多个 init 函数，它们会在程序启动时自动执行，而且不需要显式调用。

init 函数的声明格式为：

func init() {
    // 初始化操作
}

init 函数可以用来完成一些常量的初始化、变量的初始化、注册数据库驱动程序、注册 HTTP 处理器等操作。在 init 函数中，还可以使用 panic 函数来抛出异常，如果发生异常，程序会中断运行。

需要注意的是，init 函数的执行顺序是按照包的依赖关系来确定的。如果一个包依赖其他包，那么其他包的 init 函数会先被执行。在同一个包中，init 函数的执行顺序是按照声明的顺序来确定的。

另外，如果一个包中包含多个 init 函数，它们的执行顺序是不确定的，因此应该尽量避免在同一个包中使用多个 init 函数。

总之，init 函数是 Go 语言中一种非常有用的特性，可以用来完成程序的初始化和配置操作，提高程序的可靠性和可维护性。

有缓冲通道跟无缓冲通道有了解吗？

没有缓冲的这个channel，然后如果发送的话，当时没有接收，那么发送方就会阻塞，他没发送的话，但是他去接收了，那么接收方就会阻塞。有缓存的情况下的话，就是如果他这个缓存满了的话，那么这个他还要发的话，发送就会阻塞。但是在这个缓存是空的时候，然后这个没有发送，但是他去接收了这个也会发生阻塞。

Golang里面的进程线程跟协程有区别吗？

在 Go 语言中，进程、线程和协程都是并发编程中的概念，但它们在实现方式和特点上有很大的区别。

进程是操作系统中的一个概念，它是指运行中的程序的一个实例，拥有独立的地址空间、内存、文件描述符等资源。在多任务操作系统中，可以同时运行多个进程，每个进程都是独立的，并且由操作系统进行调度和管理。

线程是进程中的一个执行单元，它可以看作是轻量级的进程，拥有独立的栈和寄存器等信息，但共享进程的地址空间、内存和文件描述符等资源。线程是操作系统中最小的调度单位，可以由操作系统进行调度和管理。

协程是一种轻量级的线程，也称为用户态线程或绿色线程，它是由程序员自己管理的，不依赖于操作系统的线程管理机制。在 Go 语言中，协程被称为 goroutine，它可以看作是一种轻量级的线程。协程可以在同一个线程内并发执行，每个协程都拥有自己的栈空间，并且可以通过通道（channel）进行通信和同步。相对于线程，协程的切换成本更低，可以更好地发挥多核 CPU 的性能优势。

因此，虽然进程、线程和协程都是并发编程中的概念，但它们在实现方式和特点上有很大的区别。在 Go 语言中，协程（goroutine）是一种特殊的并发机制，它相对于线程具有更高的效率和更方便的编程接口，是 Go 语言并发编程的核心特性之一。

假如我在Golang里面，假如启动了 3 个携程，嗯，子携程，然后我想要等待坐在主携程里面，等待我的 3 个子携程都执行完了之后，然后我的主协程才继续往下走。然后这个功能要怎么去实现？有哪些实现方法？

在 Go 语言中，可以通过使用 WaitGroup 来实现等待多个 goroutine 执行完毕后再继续执行主 goroutine。

WaitGroup 是一个计数器，它的值可以增加或减少，在主 goroutine 中调用 Add 方法增加计数器的值，每个子 goroutine 在执行完毕后调用 Done 方法减少计数器的值，主 goroutine 在调用 Wait 方法时会一直阻塞，直到计数器的值变为 0。

以下是一个使用 WaitGroup 的示例代码：

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()  // 减少计数器的值

    fmt.Printf("Worker %d starting\n", id)

    // 模拟工作
    for i := 0; i < 5; i++ {
        fmt.Printf("Worker %d working...\n", id)
    }

    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)  // 增加计数器的值
        go worker(i, &wg)
    }

    wg.Wait()  // 等待所有子 goroutine 执行完毕

    fmt.Println("All workers done")
}

在上面的代码中，使用 sync 包中的 WaitGroup 类型来实现等待多个 goroutine 执行完毕后再继续执行主 goroutine。在主 goroutine 中创建 WaitGroup 对象，并调用 Add 方法增加计数器的值，然后启动 3 个子 goroutine，每个子 goroutine 在执行完毕后调用 Done 方法减少计数器的值。最后，主 goroutine 在调用 Wait 方法时会一直阻塞，直到计数器的值变为 0，即所有子 goroutine 都执行完毕。

另外，还可以使用通道（channel）实现等待多个 goroutine 执行完毕后再继续执行主 goroutine，具体实现方式是创建一个带缓冲的通道，在启动每个子 goroutine 时将通道传递给它们，在每个子 goroutine 执行完毕后向通道发送一个信号，主 goroutine 在从通道中接收到足够的信号后才继续执行。

假如我的子携程里面有一个网络请求可能阻塞了。那我想要在 30 秒钟之后加一个超时间， 30 秒钟就不管有没有成功，失败都要返回来。怎么做？

加一个超时时间。 对，我想要我的子携程最多只运行 30 秒。 这个不会。

怎么进入到我的Docker容器里面呢？

可以使用 docker exec 命令进入到正在运行的 Docker 容器中。docker exec 命令可以在容器内部执行指定的命令。

以下是使用 docker exec 命令进入到 Docker 容器的示例：

1. 使用 docker ps 命令查看正在运行的容器：

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS     NAMES
a3e1c3d3e71c   nginx:latest   "/docker-entrypoint.…"   3 minutes ago   Up 3 minutes   80/tcp    my-nginx

2. 使用 docker exec 命令进入到容器中：

$ docker exec -it a3e1c3d3e71c /bin/bash
root@a3e1c3d3e71c:/#

在上面的命令中，-it 参数表示要以交互式的方式进入容器，a3e1c3d3e71c 是容器的 ID，/bin/bash 是要在容器内部执行的命令。执行命令后，会进入到容器的交互式命令行界面。

需要注意的是，进入到容器内部后，可以执行任何命令来查看或修改容器内部的文件系统，但是这些修改都只会在容器内部生效，并不会影响到宿主机或其他容器。如果想要退出容器，可以输入 exit 命令或者使用快捷键 Ctrl + D。

Exec 跟 soccer touch 有区别吗？

在 Docker 容器中，exec 和 touch 的作用与在宿主机上相同，但是它们的行为可能会有所不同。

docker exec 命令用于在正在运行的 Docker 容器中执行命令。它可以用于进入容器的命令行界面，或者在容器内部执行指定的命令。在容器中使用 docker exec 命令时，它会在容器内部启动一个新的进程，并在该进程中执行指定的命令或者进入交互式终端。

touch 命令则用于在容器内部创建或修改文件的时间戳。在容器内部使用 touch 命令时，它会尝试在容器内部创建或修改指定的文件，并将该文件的访问时间和修改时间设置为当前时间。

需要注意的是，在 Docker 容器中使用 exec 命令或者 touch 命令时，它们只会对容器内部的文件系统产生影响，不会对宿主机或其他容器产生影响。因此，在使用这些命令时需要确保它们在正确的容器中执行，并且不会对其他容器或宿主机造成不必要的影响。

Docker 有哪些方式可以实现把端口跟宿主机上的某一个端口进行绑定？

在 Docker 中，可以使用以下三种方式将容器内部的端口与宿主机上的端口绑定：

1. 使用 -p 参数

使用 -p 参数可以将容器内部的端口映射到宿主机上的端口。语法为 -p [宿主机端口]:[容器内部端口]，其中 [宿主机端口] 是宿主机上的端口，[容器内部端口] 是容器内部的端口。

例如，以下命令将容器的 80 端口映射到宿主机上的 8080 端口：

docker run -p 8080:80 nginx

2. 使用 --publish 参数

使用 --publish 参数也可以将容器内部的端口映射到宿主机上的端口。语法为 --publish [宿主机端口]:[容器内部端口]，其中 [宿主机端口] 是宿主机上的端口，[容器内部端口] 是容器内部的端口。

例如，以下命令将容器的 80 端口映射到宿主机上的 8080 端口：

docker run --publish 8080:80 nginx

3. 使用 --expose 参数

使用 --expose 参数可以在容器内部将端口暴露出来，但是并不会将端口映射到宿主机上。如果需要将容器内部的端口映射到宿主机上，还需要使用 -p 或 --publish 参数。

例如，以下命令将容器的 80 端口暴露出来，但不会将端口映射到宿主机上：

docker run --expose 80 nginx

需要注意的是，将容器内部的端口映射到宿主机上时，需要确保宿主机上的端口没有被占用。如果宿主机上的端口已经被占用，可以使用其他端口进行映射。

构建Docker的时候，怎么把一个资源放到我的容器内部呢？

在构建 Docker 镜像时，可以使用 ADD 或 COPY 命令将宿主机上的资源复制到镜像中，从而将资源放到容器内部。

ADD 命令用于将指定的本地文件、目录或远程 URL 添加到镜像中。语法为 ADD [宿主机路径] [容器路径]，其中 [宿主机路径] 是宿主机上的文件或目录路径，[容器路径] 是镜像中的路径。

例如，以下命令将宿主机上的 index.html 文件复制到镜像中的 /usr/share/nginx/html 目录中：

ADD index.html /usr/share/nginx/html/

COPY 命令也用于将指定的本地文件或目录复制到镜像中。语法为 COPY [宿主机路径] [容器路径]，其中 [宿主机路径] 是宿主机上的文件或目录路径，[容器路径] 是镜像中的路径。

例如，以下命令将宿主机上的 index.html 文件复制到镜像中的 /usr/share/nginx/html 目录中：

COPY index.html /usr/share/nginx/html/

需要注意的是，ADD 命令还支持自动解压缩压缩文件，例如 tar 文件和 zip 文件等。如果要将压缩文件解压缩到镜像中，可以使用 ADD 命令，例如：

ADD nginx.tar.gz /usr/local/

上述命令会将 nginx.tar.gz 文件解压缩到镜像中的 /usr/local 目录中。

需要注意的是，将资源复制到镜像中会增加镜像的大小，因此应该尽可能地减小镜像的大小，避免不必要的资源复制。另外，如果需要在容器运行时动态地添加资源，也可以使用 docker cp 命令将资源复制到正在运行的容器中。

在容器里面把某一个目录挂载到我的宿主机上。那这个挂载我可以通过什么参数来实现？

在 Docker 中，可以使用 -v 或 --mount 参数将容器内部的目录挂载到宿主机上。语法为 -v [宿主机路径]:[容器路径] 或 --mount type=bind,source=[宿主机路径],target=[容器路径]，其中 [宿主机路径] 是宿主机上的目录路径，[容器路径] 是容器内部的目录路径。

例如，以下命令将容器中的 /app 目录挂载到宿主机上的 /home/user/app 目录中：

docker run -v /home/user/app:/app myimage

或者，使用 --mount 参数：

docker run --mount type=bind,source=/home/user/app,target=/app myimage

在上述命令中，-v 和 --mount 参数都可以用于挂载宿主机上的目录到容器中。-v 参数更为简单，但 --mount 参数更加灵活，可以支持更多的高级配置选项，例如指定挂载的权限、设置 SELinux 标签等。

需要注意的是，挂载目录时需要确保宿主机上的目录存在，并且具有正确的权限。如果宿主机上的目录不存在，Docker 会自动创建该目录，并使用默认的权限进行挂载。如果需要设置其他权限，可以使用 -o 或 --options 参数指定。

另外，如果需要挂载一个容器内部的文件而不是目录，可以使用 -v 或 --mount 参数指定文件路径，例如：

docker run -v /home/user/config.ini:/app/config.ini myimage

上述命令将容器内部的 /app/config.ini 文件挂载到宿主机上的 /home/user/config.ini 文件中。