Linux系统编程 day06 进程间通信

已于 2023-11-28 23:17:05 修改
阅读量890 收藏 19
点赞数 15
分类专栏： Linux系统编程 文章标签： linux 服务器 运维 c语言 ubuntu
于 2023-11-28 22:58:52 首次发布
月仙儿
本文链接：https://blog.csdn.net/qq_42198306/article/details/134632655
版权

进程间通信

1. 进程间通信的概念

在Linux的环境下，进程地址空间是相互独立的，每个进程有着各自不同的用户地址空间。一个进程不能访问另一个进程中的内容，要进行数据交换必须要通过内核，在内核中开辟块缓冲区，一个进程将数据从用户空间拷贝到内核缓冲区中，另一个进程从内核缓冲区中将数据读走。内核提供的这种机制称为进程间通信（IPC）。

在进程间完成数据传输需要借助操作系统提供的特殊方法，比如文件、管道、FIFO、内存映射区、消息队列、信号、套接字等。如今常用的进程间通信主要有管道（最简单）、信号（开销最小）、内存映射区（无血缘关系）、本地套接字（最稳定）。

2. 匿名管道pipe

管道是一种最基本的进程间通信机制，也称为匿名管道，应用于有血缘关系的进程间进行通信。管道的本质是一块内核缓冲区，内部使用的环形队列实现，由两个文件描述符进行引用，其中一个表示读端，另一个表示写端。管道的数据从管道的写端流入管道，从读端流出。当两个进程都死亡的时候，管道也会自动消失。管道不管读端还是写端默认都是阻塞的。管道的默认缓冲区大小为4K，可以使用ulimit -a命令获取大小。

在这里插入图片描述

管道的数据一旦被读走，便不在管道中存在，不可以反复读取。管道的数据只能在一个方向上流动，如果需要实现双向流动则需要使用两个管道。匿名管道只能在有血缘关系的进程中使用。我们用pipe函数来创建管道。

在这里插入图片描述

pipe函数的原型如下：

       #include <unistd.h>
			
       int pipe(int pipefd[2]); // 创建管道

其中pipefd为管道写端和读端的文件描述符，其中pipefd[0]为管道读端的文件描述符，pipefd[1]为管道写端的文件描述符。当函数调用成功创建了管道返回0，失败则返回-1并设置errno。

在使用匿名管道进行通信的时候，一般是先用pipe函数创建管道，再使用fork函数创建子进程。这样父子进程就具有了相同的文件描述符，就会指向同一个管道。

在管道的通信中，读写数据也是使用read和write。管道的示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

int main()
{
	// 创建管道
	//int pipe(int pipefd[2]);
	int fd[2];
	int ret = pipe(fd);
	if(ret < 0)
	{
		perror("pipe error");
		return -1;
	}

	// 创建子进程
	pid_t pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}
	else if(pid == 0)
	{
		// 子进程关闭写端
		close(fd[1]);
		char buf[1024];
		memset(buf, 0x00, sizeof(buf));
		sleep(5);
		read(fd[0], buf, sizeof buf);
		printf("child: read over, pid = [%d], fpid = [%d], buf = [%s]\n", getpid(), getppid(), buf);
	}
	else
	{
		// 父进程关闭读端
		close(fd[0]);
		write(fd[1], "helloworld", strlen("helloworld"));
		printf("father: write over, pid = [%d], fpid = [%d]\n", getpid(), getppid());
		pid_t wpid = wait(NULL);
		printf("child [%d] is dead!\n", wpid);
	}

	return 0;
}

在shell中我们查询某一个进程的时候我们会使用ps -ef | grep --color=auto bash，这里的|就是管道。我们使用父进程进程去执行ps -ef命令，由于我们需要交给grep去作为输入，所以在父进程中需要将输出重定向到管道的写端。子进程执行grep的时候会从输入进行读取内容，因此我们需要将输入重定向到管道读端。重定向的时候需要使用dup2函数，需要执行命令则需要使用execl和execlp函数，示例程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>


int main()
{
	// 创建管道
	int pipefd[2];
	int ret = pipe(pipefd);
	if(ret < 0)
	{
		// 创建失败
		perror("pipe error");
		return -1;
	}
	// 创建子进程
	pid_t pid = fork();
	if(pid < 0)
	{
		// 创建失败
		perror("fork error");
		return -1;
	}
	else if(pid == 0)
	{
		// 子进程关闭写端
		close(pipefd[1]);
		// 将标准输入重定向到管道读端
		dup2(pipefd[0], STDIN_FILENO);
		execlp("grep", "grep", "--color=auto", "bash", NULL);
		perror("execlp error");
	}
	else 
	{
		// 父进程关闭读端
		close(pipefd[0]);
		// 将标准输出重定向到管道写端
		dup2(pipefd[1], STDOUT_FILENO);
		execlp("ps", "ps", "-ef", NULL);
		perror("execlp error");
	}
	return 0;
}

当管道有数据的时候，read可以正常读，并返回读出来的字节数；当管道没有数据的时候，若写端全部关闭，则read函数解出阻塞状态，返回0，相当于读文件读到了尾部。若写端没有关闭，则read阻塞。

若读端全部关闭，进行写操作的时候则管道会破裂，进程终止，内核会给当前进程发送SIGPIPE信号。若读端没有完全关闭，缓冲区写满了则write会阻塞，缓冲区没有满则可以继续write。

管道默认两端都是阻塞的，若要设置为非阻塞，则可以使用前面提过的fcntl函数。首先使用F_GETFL获取flags，然后在添加O_NONBLOCK使用F_SETFL设置即可。当读端设置为非阻塞状态的时候，会有以下四种情况：

  • 写端没有关闭，管道中没有数据可读，则read返回-1。
  • 写端没有关闭，管道中有数据可读，则read返回实际读到的字节数。
  • 写端已经关闭，管道中有数据可读，则read返回实际读到的字节数。
  • 写端已经关闭，管道中没有数据可读，则read返回0。

设置的流程为：

int flags = fcntl(fd[0], F_GETFL, 0);
flags = flags | O_NONBLOCK;
fcntl(fd[0], F_SETFL, flags);

除了前面使用的ulimit -a可以查看到管道缓冲区的大小之外，也可以使用fpathconf函数，该函数的原型为：

       #include <unistd.h>

       long fpathconf(int fd, int name);

这个函数会根据name的参数设置返回文件描述符fd对应文件的配置内容。比如获取管道缓冲区则需要把name设置为_PC_PIPE_BUF。如下面查看管道的缓冲区大小。

printf("pipe size = [%ld]\n", fpathconf(fd[0], _PC_PIPE_BUF));
printf("pipe size = [%ld]\n", fpathconf(fd[1], _PC_PIPE_BUF));

更多的name参数设置可以使用man fpathconf查询帮助文档。

3. 命名管道FIFO

使用pipe管道只能实现有血缘关系的两个进程间的通信，那么对于两个没有血缘关系的进程又应该怎么实现呢？则需要这一节的命名管道FIFO。

FIFO是Linux上基于文件类型的一种通信方式，文件类型为p，但是FIFO在磁盘上并没有数据块，文件大小为0，仅仅用于标识内核中的一条通道。进程可以通过read或者write函数去对这一条通道进行操作，也就是内核缓冲区，这样就实现了进程间的通信。

要使用命名管道，就得先创建命名管道文件，创建管道文件使用mkfifo函数，该函数的原型为：

       #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);

其中参数第一个pathname表示管道的路径名，mode表示权限，使用一个三位八进制数表示。创建成功函数返回0，创建失败则函数返回-1并设置errno。

FIFO严格遵守先进先出的规则，也就是对于管道的读总是从管道的开始处返回数据，而对于管道的写则是添加到末尾。因此命名管道不支持使用lseek等对文件定位的操作。

使用FIFO完成进程间通信的示意图如下：

在这里插入图片描述

既然是两个进程，也就是说两个进程中的程序都需要打开管道，也就是需要找到文件。若写进程没有打开就去使用读进程，则可能因为管道的文件不存在而报错。因此我们在使用管道或者创建管道之前要先判断文件是否存在。这个可以使用access函数实现，该函数的原型为：

       #include <unistd.h>

       int access(const char *pathname, int mode);

该函数的第一个参数pathname是文件的路径，第二个参数mode表示要测试的模式，有四个参数可以传，分别为：

  • F_OK： 文件存在
  • R_OK：有读权限
  • W_OK：有写权限
  • X_OK：有执行权限

当有对应的权限或者文件存在的时候，该函数的返回值为0，若没有对应权限或者文件不存在则该函数返回-1。

接下来我们实现两个无血缘关系之间的进程间通信。代码如下：

fifo_write.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

// FIFO 写进程
int main()
{
	// 创建FIFO文件
	// int access(const char *pathname, int mode);
	int ret = access("./myfifo", F_OK);
	if(ret < 0)
	{
		// int mkfifo(const char *pathname, mode_t mode);
		ret = mkfifo("./myfifo", 0777);
		if(ret < 0)
		{
			perror("mkfifo error");
			return -1;
		}
	}

	// 打开FIFO
	int fd = open("./myfifo", O_RDWR);
	if(fd < 0)
	{
		perror("open error");
		return -1;
	}

	// 传输数据
	char buf[1024] = "hello world";
	write(fd, buf, strlen(buf));
	sleep(1);

	// 关闭FIFO
	close(fd);

	return 0;
}

fifo_read.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// FIFO 读进程端
int main()
{
	// 判断创建FIFO
	int ret = access("./myfifo", F_OK);
	if(ret < 0)
	{
		int ret = mkfifo("./myfifo", 0777);
		if(ret < 0)
		{
			perror("mkfifo error");
			return -1;
		}
	}

	// 打开FIFO
	int fd = open("./myfifo", O_RDWR);
	if(fd < 0)
	{
		perror("open error");
		return -1;
	}

	// 接收数据
	char buf[1024];
	memset(buf, 0x00, sizeof buf);
	read(fd, buf, sizeof buf);
	printf("%s\n", buf);

	// 关闭FIFO
	close(fd);

	return 0;
}

在上述代码中，只要运行，不管是读进程还是写进程先运行，只要写进程没有往管道中写数据，读进程都会阻塞在read处。直到写进程调用write函数往管道中写数据之后读进程才会读出来管道中的数据输出。

4. 内存映射区

内存映射区是将一个磁盘文件与内存空间的一个缓冲区向映射。当我们在缓冲区中读取数据的时候，就相当于在文件中读取相应的字节。若我们向缓冲区中写数据，则会把数据写入对应的文件之中。这样就可以在不使用read函数和write函数啊的情况下使用指针完成IO操作。

在这里插入图片描述

映射这个过程可以使用mmap函数实现。解除映射可以使用munmap实现。函数的原型以及参数如下：

       #include <sys/mman.h>
			
		// 函数作用: 建立存储映射区
		// 返回值: 成功：返回创建的映射区首地址
		//		  失败： 返回MAP_FAILED宏， 实际上就是(void *)-1
		// 参数: addr: 指定映射的起始地址，通常设为NULL，由系统指定
		//      length: 映射到内存的文件长度
		//       prot: 映射区的保护方式，最常用的有
		//                PROT_READ   				读
		//                PROT_WRITE  				写
		//                PROT_READ | PORT_WRITE    读写
		//       flags: 映射区的特性，可以设置以下
		//                MAP_SHARED   写入映射区的数据会写回文件，且允许
		//							   其它映射改文件的进程共享。
		//                MAP_PRIVATE  对映射区的写入操作会产生一个映射区的复
		//  						 	制，对此区域所做的修改不会写回原文件。
		//                MAP_ANONYMOUS  匿名映射区，需要结合MAP_SHARED使用。
		// 	      fd: 代表要映射的文件，由open函数返回的文件描述符
		//        offset: 以文件开始出的偏移量,必须是4K的整数倍，通常为0，表示
		//                从文件头开始映射
       void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);

		// 函数作用: 释放由mmap函数建立的存储映射区
		// 返回值： 成功返回0，失败返回-1并设置errno
		// 参数： addr: 调用mmap函数成功返回的映射区首地址
		//  	 length: 映射区的大小
       int munmap(void *addr, size_t length);

需要注意到的是，mmap函数不能开辟长度为0的存储映射区。在使用mmap函数创建映射区的过程中，隐含着一次对映射文件的读操作，将文件读取到映射区。当我们将flags设置为MAP_SHARED的时候，要求映射区的权限应该小于或者等于文件打开的权限，这是出于对映射区的保护。而对于MAP_PRIVATE，则是没有这个必要，因为mmap中的权限是对内存的限制。

在映射区建立之后，映射区的释放是与文件的关闭无关的，所以在映射区建立之后就可以关闭文件。在创建映射区的时候，使用mmap函数常常会出现总线错误，通常是因为共享文件存储空间大小引起的。所以创建映射区的时候出错的概率比较高，因此一定要检查函数的返回值，确保映射区建立成功了再进行后续的操作。使用munmap函数的时候，传入的地址一定要是mmap函数的返回值，一定不要改变指针的指向。其中函数的参数中offset也是需要注意的，不能随便指定，必须要是4K的整数倍才行。

下面给出一个关于关于有血缘关系的进程间的通信示例。

//使用mmap完成有血缘关系进程间的通信
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>

int main()
{
	//使用mmap函数建立共享映射区
	//void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
	int fd = open("test.log", O_RDWR);
	if(fd < 0)
	{
		perror("open error");
		return -1;
	}

	int len = lseek(fd, 0, SEEK_END);

	void *addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
	if(addr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}

	close(fd);

	//创建子进程
	pid_t pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}
	else if(pid == 0)
	{
		//子进程
		sleep(2);
		char *p = (char *)addr;
		printf("[%s]\n", p);
	}
	else
	{
		//父进程
		memcpy(addr, "hello world", strlen("hello world"));
		wait(NULL);
	}

	return 0;
}

共享存储映射区也可以用于没有血缘关系的两个进程。

写进程

// 使用mmap完成没有血缘关系的进程间的通信
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>


// 写进程
int main()
{
	// 使用mmap函数建立共享映射区
	int fd = open("test.log", O_RDWR);
	if(fd < 0)
	{
		perror("open error");
		return -1;
	}

	int len = lseek(fd, 0, SEEK_END);

	// 建立共享映射区
	void *addr = mmap(NULL, len, PROT_WRITE, MAP_SHARED, fd, 0);
	if(addr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}

	close(fd);

	memcpy(addr, "Good morning", strlen("Good morning"));

	return 0;
}

读进程

// 使用mmap完成没有血缘关系的两个进程间的通信
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>

// 读进程端
int main()
{
	// 使用mmap函数建立共享映射区
	int fd = open("test.log", O_RDONLY);
	if(fd < 0)
	{
		perror("open error");
		return -1;
	}

	int len = lseek(fd, 0, SEEK_END);

	// 建立共享映射区
	void *addr = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
	if(addr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}

	char *p = (char *)addr;
	printf("[%s]\n", p);

	return 0;
}

上面的共享存储映射区都是有名字的，我们也可以创建匿名的共享存储映射区。匿名映射区是不需要使用文件去创建的，因此没有血缘关系的两个进程不能使用匿名映射区通信。在使用匿名共享映射区的时候，文件的描述符一般传为-1。关于匿名共享映射区的示例代码如下：

// 建立匿名共享映射区
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <fcntl.h>

int main()
{
	void *addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	if(addr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}

	pid_t pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}
	else if(pid == 0)
	{
		sleep(2);
		char *p = (char *)addr;
		printf("[%s]\n", p);
	}
	else
	{
		memset(addr, 0x00, 4096);
		memcpy(addr, "hello world", strlen("hello world"));
		wait(NULL);
	}

	return 0;
}

后续博客关于函数原型以及作用均以注释的形式写在代码中以便直观

月仙儿
关注
  • 15
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统编程——进程控制
蹦跶跶
07-29 536
进程控制1. 进程相关1.1 CPU 与 MMU1.1.1 CPU1.1.2 MMU（内存管理单元）1.3 进程控制块PCB2. 环境变量2.1 常见环境变量2.2 相关环境变量函数2.2.1 getenv函数2.2.2 setenv函数2.2.1 unsetenv函数3. 进程控制3.1 进程ID相关函数3.2 子进程创建3.2.1 创建一个子进程3.2.2 循环创建n各子进程3.3 进程共享3.4 gdb调试 1. 进程相关 1.1 CPU 与 MMU 1.1.1 CPU CPU 执行一条指令过程：预
day06(进程间通信).rar
02-13
linux进程间通信代码部分，Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在...
Linux系统编程——进程间通信
Alliswell_WP
07-01 214
在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 目录：一、学习目标二、进程通信——管道1、管道的概念2、管道通信举例3、父子进程实现ps、grep命令4、ps、grep命令实现问题解决5、管道的读写行为6、管道大小和优劣三、进程通信——FIFO1、fifo实现通信写端2、fifo...
Linux系统编程——09-linux-day06(进程间通信)
Alliswell_WP
07-01 173
在学习Linux系统课程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day06(进程间通信) 一、学习目标 1、熟练使用pipe进行父子进程间通信 2、熟练使用pipe进行兄弟进程间通信 3、熟练使用fifo进行无血缘关系的进程间通信 4、熟练掌握mmap函数的使用 5、掌握mmap创建匿名映射区的方法 6、使用mm...
Linux系统编程Day06
weixin_46412362的博客
03-07 111
1.进程状态 1.1 孤儿进程 父进程运行结束，但子进程还在运行（未运行结束）的子进程就称为孤儿进程 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的已经退出的子进程。 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<unistd.h> int main() { pid_t pid =
Linux系统编程【文件IO、进程、进程间通信、信号、线程、互斥】
weixin_45045804的博客
09-29 1584
个人通过学习，手打了一份48000字的Linux系统编程的笔记，包含了【文件IO、进程、进程间通信、信号、多线程、互斥】等知识点，并给出了大量的代码案例对每个重要的知识点进行了代码演示，通过理论和实操的结合，更好的透析每个知识点，为后续的unix网络编程打下基础。
linux fifo通信,linux 进程间通信 之fifo
weixin_35637837的博客
05-14 963
上一篇博客已经介绍了一种进程间通信的方式，但是那只是针对于有血缘关系的进程，即父子进程间的通信，那对于没有血缘关系的进程，那要怎么通信呢？这就要创建一个有名管道，来解决无血缘关系的进程通信, fifo:book@ubuntu:~$ mkfifo xwpbook@ubuntu:~$ ls -l myfifoprw-rw-r-- book book Feb myfifomkfifo 既有命...
Linux进程控制day02（进程间通信）
ZY1732331520的博客
09-04 91
基本概念： 什么是进程间通信： 是指两个或多个进程之间交互数据的过程，因为进程之间是相互独立，为了协同工作必须交互数据。 进程间通信的分类： 1、 简单的进程间通信：信号、文件、环境变量、命令行参数。 2、传统的进程间通信：管道文件（有名管道、匿名管道） 3、XSI进程间通信：共享内存、消息队列、信号量。 4、网络进程间通信：套接字 传统进程间通-管道 管道是UNIX系统中最古老的进程间通信方式，古老就意味着所有系统都支持，早期的管道都是半双工，现在有些
Linux C编程之十一 进程间通信
weixin_30955341的博客
05-14 175
一、整体大纲 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess ...
Linux系统编程Day01
weixin_46412362的博客
03-01 131
1.Linux常见目录介绍 /：根目录，一般根目录下只存放目录，在Linux下有且只有一个根目录。所有的东 西都是从这里开始。当你在终端里输入“/home”，其实是在告诉电脑，先从/（根目录） 开始，再进入到home目录。 /bin: /usr/bin: 可执行二进制文件的目录，如常用的命令ls、tar、mv、cat等。 /boot：放置linux系统启动时用到的一些文件，如Linux的内核文件：/boot/vmlinuz， 系统引导管理器：/boot/grub。 /dev：存放linux系
Linux操作系统day01.pdf
03-28
12. Linux系统命令分类 Linux操作系统的命令可以分为两大类：bash内置的命令和应用程序。用户可以通过which命令查看哪些命令是bash内置的命令，哪些是应用程序。 13. shell实用功能 Linux操作系统提供了许多shell...
进程间通信（管道、消息队列、共享内存、信号量）.docx
07-22
例如，在一个系统中，多个进程需要共享同样的资源，这时就需要使用进程间通信来传输数据。 资源共享：进程间通信也可以用于共享资源，例如，多个进程可以共享同一个文件或数据库。 通知事件：进程间通信还可以用于...
达内linux高级编程day2经典案例
09-08
达内linux高级编程day2经典案例
DAY3 网络编程 多点通信
10-20
DAY3 网络编程 多点通信
Linux 6: 正则表达式 - 2024-08-Week1
weixin_48029567的博客
08-04 114
正则表达式：Regular expression是处理字符串的方法，常常用来某些特定的字符串。
Linux shell编程学习笔记68： curl 命令行网络数据传输工具 选项数量雷人（上）
Purpleendurer@CSDN
08-04 645
在网络时代，有经常需要在网络上传输数据，时我们需要通过网络下载文件，为了满足这种时代需要，Linux提供了众多网络命令，我们今天先研究curl命令。例如，我们可以使用curl从 URL 下载文件，或将文件上传到服务器。
Linux文件管理和IO重定向知识总结
qq_41934502的博客
08-04 316
文件管理+IO重定向介绍
【Linux】wsl win安装Linux环境
最新发布
weixin_44623642的博客
08-04 277
打开开始菜单，在开始菜单中输入 启用或关闭 Windows 功能，在弹出的窗口中勾选 虚拟机平台 和 适用于 Linux 的 Windows 子系统，确定之后重启系统。Windows 下的所有文件都被挂载在了 /mnt 下，在Windows 终端中的任意目录下输入 wsl，即可进入 Linux 对应的路径。首次运行时，会让你先输入用户名，再输入密码（密码不可见，输完回车即可），不设置也可以，不过所有命令都是是在sudo状态下。，确定以后，弹出对话框要求重启计算机，重启即可。查看Ubuntu版本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值