IO进程线程day4（2023.8.1）

最新推荐文章于 2024-08-28 20:58:28 发布
最新推荐文章于 2024-08-28 20:58:28 发布
阅读量228 收藏
点赞数
分类专栏： IO进程线程 文章标签： myeclipse ide java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68542867/article/details/132035693
版权

一、Xmind整理：

进程的五态图：

 内存分布图：

 注：栈区：存储局部变量，形参（上边打错了！！！）

虚拟内存和物理内存：

进程的STAT：

二、课上练习：

练习1：将课上的文件权限提取修改成循环方式

#include <stdio.h>
#include <head.h>

void get_filePermission(mode_t m)
{
	//方法一：
	/*
	   for(int i=0;i<9;i++)
	   {
	   if((m&(0400>>i))==0)
	   {
	   putchar('-');
	   continue;
	   }
	//能运行到当前位置，则代表对应位置有权限
	//需要判断是r  w  x当中的哪一个
	switch(i%3)
	{
	case 0:putchar('r');break;
	case 1:putchar('w');break;
	case 2:putchar('x');break;
	}
	}
	*/

	//方法二：
	char buf[]="rwx";
	for(int i=0;i<9;i++)
	{
		if((m&(0400>>i))==0)
		{
			putchar('-');
			continue;
		}
		printf("%c",buf[i%3]);
	}
	return;
}
int main(int argc, const char *argv[])
{
	struct stat buf;
	if(stat("./2.png", &buf) < 0)
	{
		ERR_MSG("stat");
		return -1;
	}

	//文件的类型和权限
	printf("mode: 0%o\n", buf.st_mode);
	get_filePermission(buf.st_mode);

	//文件的硬链接数
	printf("link: %ld\n", buf.st_nlink);

	//文件的所属用户
	printf("uid: %d\n", buf.st_uid);

	//文件所属组用户
	printf("gid: %d\n", buf.st_gid);

	//文件大小
	printf("size: %ld\n", buf.st_size);

	//文件的修改时间
	printf("time: %ld\n", buf.st_ctime);

	return 0;
}

练习2：提取文件的类型

mode_t    st_mode   本质上是一个unsigned int类型，里面存储了文件的类型和权限。
方法1： 
man 2 stat --> st_mode --->see inode(7)
man 7 inode -->

           S_ISREG(m)  is it a regular file?                         -

           S_ISDIR(m)  directory?                                    d

           S_ISCHR(m)  character device?                             c

           S_ISBLK(m)  block device?                                 b

           S_ISFIFO(m) FIFO (named pipe)?                            p

           S_ISLNK(m)  symbolic link?  (Not in POSIX.1-1996.)        l

           S_ISSOCK(m) socket?  (Not in POSIX.1-1996.)               s

若是该类型文件，则返回真，否则返回假
void get_fileType(mode_t m) 
{
    if(S_ISREG(m))
        putchar('-');

    else if(S_ISDIR(m))
        putchar('d');

    else if(S_ISCHR(m))
        putchar('c');       

    return ;

}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
void get_fileType(mode_t m)
{
	if(S_ISREG(m))
		putchar('-');
	else if(S_ISDIR(m))
		putchar('d');
	else if(S_ISCHR(m))
		putchar('c');
	else if(S_ISBLK(m))
		putchar('b');
	else if(S_ISFIFO(m))
		putchar('p');
	else if(S_ISLNK(m))
		putchar('l');
	else if(S_ISSOCK(m))
		putchar('s');

	return;
}
int main(int argc, const char *argv[])
{
	struct stat buf;
	if(stat("./2.png", &buf) < 0)
	{
		ERR_MSG("stat");
		return -1;
	}

	//文件的类型和权限
	printf("mode: 0%o\n", buf.st_mode);
	get_fileType(buf.st_mode);   
	//文件的硬链接数
	printf("link: %ld\n", buf.st_nlink);

	//文件的所属用户
	printf("uid: %d\n", buf.st_uid);

	//文件所属组用户
	printf("gid: %d\n", buf.st_gid);

	//文件大小
	printf("size: %ld\n", buf.st_size);

	//文件的修改时间
	printf("time: %ld\n", buf.st_ctime);

	return 0;
}

方法2： 
mode       0040775
S_IFMT     0170000   bit mask for the file type bit field

mode       0040775 ---> 000 100 000 111 111 101
S_IFMT     0170000 ---> 001 111 000 000 000 000  &
                    ------------------------------
                        000 100 000 000 000 000 ---> 040000

与下列宏进行比较，与哪个相同，就是对应类型文件
           S_IFSOCK   0140000   socket
           S_IFLNK    0120000   symbolic link
           S_IFREG    0100000   regular file
           S_IFBLK    0060000   block device
           S_IFDIR    0040000   directory
           S_IFCHR    0020000   character device
           S_IFIFO    0010000   FIFO

mode:      0100664 ---> 001 000 000 110 110 100
S_IFMT     0170000 ---> 001 111 000 000 000 000  &
                    ------------------------------
                        001 000 000 000 000 000 ---> 0100000
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <time.h>
void get_fileType(mode_t m)
{
	switch(m&S_IFMT)
	{
	case S_IFSOCK:putchar('s');break;
	case S_IFLNK:putchar('l');break;
	case S_IFREG:putchar('-');break;
	case S_IFDIR:putchar('d');break;
	case S_IFCHR:putchar('c');break;
	case S_IFBLK:putchar('b');break;
	case S_IFIFO:putchar('p');break;
	}
	return;
}
int main(int argc, const char *argv[])
{
	struct stat buf;
	if(stat("./2.png", &buf) < 0)
	{
		ERR_MSG("stat");
		return -1;
	}

	//文件的类型和权限
	printf("0%o ", buf.st_mode);
	get_fileType(buf.st_mode);   
	//文件的硬链接数
	printf("%ld ", buf.st_nlink);

	//文件的所属用户
	printf("%d ", buf.st_uid);
	struct passwd* pwd=getpwuid(buf.st_uid);
	if(NULL==pwd)
	{
		ERR_MSG("getpwuid");
		return -1;
	}
	printf("%s ",pwd->pw_name);

	//文件所属组用户
	printf("%d ", buf.st_gid);
	struct group* grp=getgrgid(buf.st_gid);
	if(NULL==grp)
	{
		ERR_MSG("getgrgid");
		return -1;
	}
	printf("%s ",grp->gr_name);

	//文件大小
	printf("%ld ", buf.st_size);
	//文件的修改时间
	struct tm* info=NULL;
	info=localtime(&buf.st_mtime);
	//printf("%ld ",buf.st_ctime);
	printf("%02d %02d %02d:%02d ",info->tm_mon+1,info->tm_mday,info->tm_hour,info->tm_min);
	printf("2.png\n");

	return 0;
}

练习3：提取文件所属用户名

uid_t     st_uid;         /* User ID of owner */     用户的uid

getpwuid函数

功能：通过uid号获取用户的信息
原型：
 #include <sys/types.h>
 #include <grp.h>
 struct group *getgrgid(gid_t gid);
参数：
gid_t gid：指定gid号;
返回值：
成功，返回结构体指针;
失败，返回NULL;更新errno;
    struct group {
               char   *gr_name;        /* group name */
               char   *gr_passwd;      /* group password */
               gid_t   gr_gid;         /* group ID */
               char  **gr_mem;         /* NULL-terminated array of pointers
                                          to names of group members */
           };

    struct group* grp = getgrgid(buf.st_gid);
    if(NULL == grp)
    {                                             
        ERR_MSG("getgrgid");
        return -1;
    }
    printf("%s\n", grp->gr_name);
完整代码示例： 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <head.h>

//获取文件权限
void get_filePermission(mode_t m)   //mode_t m = buf.st_mode
{
    char buf[] = "rwx";

    for(int i=0; i<9; i++)
    {
        if( (m & (0400>>i)) == 0)
        {
            putchar('-');
            continue;
        }

        //能运行到当前位置，则代表对应位置有权限
        //需要判断是r w x中的哪一个                          
        /*
        switch(i%3)
        {
        case 0:
            putchar('r');
            break;
        case 1:
            putchar('w');
            break;
        case 2:
            putchar('x');
            break;
        }
        */

        printf("%c", buf[i%3]);

    }
    return;
}

//获取文件类型
void get_fileType(mode_t m)     //mode_t m = buf.st_mode
{
    switch(m & S_IFMT)
    {
    case S_IFSOCK: putchar('s');    break;
    case S_IFLNK: putchar('l');     break;
    case S_IFREG: putchar('-');     break;
    case S_IFDIR: putchar('d');     break;
    }

    return;
}


int main(int argc, const char *argv[])
{
    struct stat buf;
    if(stat("./01_fileno.c", &buf) < 0)
    {
        ERR_MSG("stat");
        return -1;
    }

    //文件的类型和权限
    //printf("mode: 0%o\n", buf.st_mode);
    get_fileType(buf.st_mode);
    get_filePermission(buf.st_mode);

    //文件的硬链接数
    //printf("link: %ld\n", buf.st_nlink);
    printf(" %ld", buf.st_nlink);

    //文件的所属用户
    //printf("uid: %d\n", buf.st_uid);
    //将uid转换成名字
    struct passwd* pwd = getpwuid(buf.st_uid);
    if(NULL == pwd)
    {
        ERR_MSG("getpwuid");
        return -1;
    }
    printf(" %s", pwd->pw_name);


    //文件所属组用户
    //printf("gid: %d\n", buf.st_gid);
    //将gid转换成名字
    struct group* grp = getgrgid(buf.st_gid);
    if(NULL == grp)
    {
        ERR_MSG("getgrgid");
        return -1;
    }
    printf(" %s", grp->gr_name);


    //文件大小
    //printf("size: %ld\n", buf.st_size);
    printf(" %ld", buf.st_size);

    //文件的修改时间
    printf(" time: %ld\n", buf.st_ctime);

    //文件的名字


    return 0;
}

练习4：opendir

功能：打开一个目录文件
原型：
 #include <sys/types.h>
 #include <dirent.h>
 DIR *opendir(const char *name);
参数：
 char *name：指定要打开的目录的路径以及名字;
返回值：
 成功，返回指针;
 失败，返回NULL，更新errno;

练习5：closedir

功能：关闭目录
原型：
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);
返回值：
 成功，返回0；
 失败，返回-1，更新errno;

练习6：readdir

功能：读取目录
原型：
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
返回值：
 成功，返回结构体指针：
 失败，返回NULL; 更新errno;
 目录读取完毕，返回NULL，不更新errno;
         struct dirent {
               ino_t          d_ino;       /* Inode number */
               off_t          d_off;       /* Not an offset; see below */
               unsigned short d_reclen;    /* Length of this record */
               unsigned char  d_type;      /* Type of file; not supported
                                              by all filesystem types */
               char           d_name[256]; /* Null-terminated filename */
           };

练习7：打印当前路径下所有文件的名字，除了隐藏文件

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <dirent.h>
#include <errno.h>
int main(int argc, const char *argv[])
{
	DIR* dp=opendir("./");
	if(NULL==dp)
	{
		ERR_MSG("opendir");
		return -1;
	}
	printf("opendir success\n");
	int i=0;
	while(1)
	{
		struct dirent* rp=readdir(dp);
		if(NULL==rp)
		{
			if(0==errno)
			{
				printf("目录读取完毕\n");
				break;
			}
			else
			{
				ERR_MSG("readdir");
				return -1;
			}
		}
		//判断是否是隐藏文件：以.字符开头
		if(rp->d_name[0]!='.')   //*(rp->d_name)
			printf("[%d]%s\n",++i,rp->d_name);
	}
	if(closedir(dp)<0)
	{
		ERR_MSG("closedir");
		return -1;
	}

	return 0;
}

练习8：fork

功能：创建一个子进程
原型：
 #include <sys/types.h>
 #include <unistd.h>
 pid_t fork(void);
返回值：
  成功， >0 , 在父进程中，返回创建的子进程的pid号;
         =0,   在子进程中，返回0;
  失败，返回-1，更新errno，且没有子进程被创建
注意： 

1.fork函数创建的子进程，会克隆父进程用户空间的所有资源，以及PC寄存器的值。所以子进程不会运行执行过的fork函数以及fork函数以上的代码。

（ps ：PC寄存器中存储着下一次该运行到哪一行代码）

2.父子进程的虚拟地址空间不是同一块，但是由于子进程是从父进程拷贝过来的，所以fork完毕的一瞬间，父子进程的用户空间长得完全一致。

3.父子进程映射的物理地址不是同一块空间。

   ①写时拷贝：当父子进程均不修改其中的内容的时候，此时映射的物理地址是同一块空间。若某个进程要修改其中的内容的时候，此时才会真正的申请一块新的物理地址空间给子进程的虚拟地址映射。

例题：任务1：验证虚拟地址相不相同
           任务2：验证映射的物理地址相不相同 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
int main(int argc, const char *argv[])
{
	printf("__%d__\n",__LINE__);
	int a=10;
	//创建一个子进程
	pid_t cpid=fork();	//在fork以下的这段代码，父子进程均运行
	if(cpid>0)//在父进程中，该条件为真
	{
		a=20;
		printf("cpid=%d a=%d %p %d\n",cpid,a,&a,__LINE__);
	}
	else if(0==cpid)//在子进程中，该条件为真
	{
		sleep(1);//主动放弃CPU资源
		printf("cpid=%d a=%d %p %d\n",cpid,a,&a,__LINE__);
	}
	else
	{
		perror("fork");
		return -1;
	}
	while(1)
	{
		sleep(1);
	}

	return 0;
}

三、课后作业：

1.从终端获取一个文件的路径以及名字。

若该文件是目录文件，则将该文件下的所有文件的属性显示到终端，类似ls -l该文件夹

若该文件不是目录文件，则显示该文件的属性到终端上，类似ls -l这单个文件

#include <stdio.h>
#include <string.h>
#include <head.h> 
void get_fileType(mode_t m)
{
	if(S_ISREG(m))
		putchar('-');
	else if(S_ISDIR(m))
		putchar('d');
	else if(S_ISCHR(m))
		putchar('c');
	else if(S_ISBLK(m))
		putchar('b');
	else if(S_ISFIFO(m))
		putchar('p');
	else if(S_ISLNK(m))
		putchar('l');
	else if(S_ISSOCK(m))
		putchar('s');

	return;
} 
void get_filePermission(mode_t m)
{
	for(int i=0;i<9;i++)
	{
		if((m&(0400>>i))==0)
		{
			putchar('-');
			continue;
		}
		//能运行到当前位置，则代表对应位置有权限
		//需要判断是r  w  x当中的哪一个
		switch(i%3)
		{
		case 0:putchar('r');break;
		case 1:putchar('w');break;
		case 2:putchar('x');break;
		}
	}
	return;
}
int getstat(char *str)
{	struct stat buf;
	if(stat(str, &buf) < 0)
	{
		ERR_MSG("stat");
		return -1;
	}

	//文件的类型和权限
	printf("0%o ", buf.st_mode);
	get_fileType(buf.st_mode);   
	//文件的硬链接数
	printf("%ld ", buf.st_nlink);

	//文件的所属用户
	//printf("uid: %d\n", buf.st_uid);
	//将uid转换成名字
	struct passwd* pwd = getpwuid(buf.st_uid);
	if(NULL == pwd)
	{
		ERR_MSG("getpwuid");
		return -1;
	}
	printf("%s ", pwd->pw_name);


	//文件所属组用户
	//printf("gid: %d\n", buf.st_gid);
	//将gid转换成名字
	struct group* grp = getgrgid(buf.st_gid);
	if(NULL == grp)
	{
		ERR_MSG("getgrgid");
		return -1;
	}
	printf("%s ", grp->gr_name);
	//文件大小
	printf("%ld ", buf.st_size);
	//文件的修改时间
	struct tm* info=NULL;
	info=localtime(&buf.st_mtime);
	//printf("%ld ",buf.st_ctime);
	printf("%02d %02d %02d:%02d ",info->tm_mon+1,info->tm_mday,info->tm_hour,info->tm_min);
	printf("%s\n",str);
}

int main(int argc, const char *argv[])
{
	char str[20]="";
	printf("please enter a filename:");
	scanf("%s",str);

	struct stat buf;
	if(stat(str,&buf) < 0)
	{
		ERR_MSG("stat");
		return -1;
	}

	if((buf.st_mode & S_IFMT) == S_IFDIR)
	{
		DIR * dp = opendir(str);
		if(NULL == dp)
		{
			ERR_MSG("opendir");
			return -1;
		}
		printf("open success \n");

		struct dirent *rp = NULL;
		int i=0;
		while(1)
		{
			rp = readdir(dp);
			if(NULL == rp)
			{
				if(0 == errno)
				{
					printf("读取完毕\n");break;
				}
				else
				{
					perror("readdir");
					return -1;
				}
			}
			if(*(rp->d_name) != '.')
				getstat(rp->d_name);
			//	printf("[%d]%s\n",++i,rp->d_name);
		}
		closedir(dp);
	}
	else
		getstat(str);

	return 0;
}

2.文件IO函数实现，拷贝文件。子进程先拷贝后半部分，父进程再拷贝前半部分。允许使用sleep函数。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
int main(int argc, const char *argv[])
{
	int fd_r = open("./1.txt",O_RDONLY);
	if(fd_r < 0)
	{
		ERR_MSG("open");
		return -1;
	}
	int fd_w = open("./2.txt",O_WRONLY|O_CREAT|O_TRUNC,0664);
	if(fd_w < 0)
	{
		ERR_MSG("open");
		return -1;
	}
	off_t len = lseek(fd_r,0,SEEK_END);
	pid_t cpid = fork();
	if(cpid > 0)
	{
		sleep(1);
		lseek(fd_r,len/2,SEEK_SET);
		lseek(fd_w,len/2,SEEK_SET);
		char c;
		for(int i=len/2;i<len;i++)
		{
			if(read(fd_r,&c,1) == 0)
			{
				break;
			}
			write(fd_w,&c,1);
		}
	}
	if(0 == cpid)
	{
		lseek(fd_r,0,SEEK_SET);
		lseek(fd_w,0,SEEK_SET);
		char a;
		for(int j=0;j<len/2;j++)
		{
			if(read(fd_r,&a,1) == 0)
			{
				break;    
			}
			write(fd_w,&a,1);
		}
	}
	close(fd_r);
	close(fd_w);

	return 0;
}

小徐今天认真学习了嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【IO进程线程】
m0_63246725的博客
03-12 105
假如A进程和B进程想要通信，按照之间讲解的进程的原理是无法完成的，A和B进程的内存空间是独立的0-3G。如果想要实现通信就必须借助内核空间才能完成，因为内核空间是共用的。在linux系统中进程间通信的方式有7种。​ 1.无名管道​ 2.有名管道​ 3.信号​ 1.消息队列​ 2.共享内存​ 3.信号灯集​ 1.套接字通信（通过网络实现进程间通信）​ 1.binder机制。
Linux学习 IO进程与线程： day4
haogewudi666的博客
06-11 428
【复习】 库：可执行代码的二进制形式 静态库：编译时 动态库(共享库)：运行时 便于复用 进程： 和程序的区别： 三段：数据段、正文段、堆栈段 分类：交互进程、批处理、守护进程 状态：运行态R、等待态、暂停态T、死亡态x、僵尸态Z 命令：ps -aux/-ef、top、kill、bg\fg 函数：fork、wait/waitpid、exit/_exit、execvpe 守护进程：1.fork 2.setsid 3.chdir...
IO进程线程day7（2023.8.4）
m0_68542867的博客
08-04 169
进程和线程的区别（重点！！！！！）、条件变量【工作原理、pthread_cond_init、pthread_cond_wait、pthread_conde_signal、pthread_cond_destroy】、信号量【工作原理、sem_init、sem_wait（P操作）、sem_post（V操作）、sem_destroy】
IO进程线程day8（2023.8.6）
m0_68542867的博客
08-07 139
什么是IPC机制【IPC机制、传统的进程间通信机制、system v操作系统的IPC对象、可用于跨主机传输的通信】 管道【管道的原理、管道的特性、无名管道（pipe）、有名管道（fifo）】 信号（signal）【信号的概念、信号的原理、进程对信号的处理方式（重点）、常见的信号、信号相关的函数】以及代码实现 要求实现AB进程对话 A进程先发送一句话给B进程，B进程接收后打印 B进程再回复一句话给A进程，A进程接收后打印 重复1.2步骤，当收到quit后，要结束AB进程
兑吧开发规范《源Java手册》
海客森
12-31 3169
1. 规范: 语法规范 1.1. 命名规范 【推荐】业务属性：对象、方法命名，要使用携带业务属性的名词，比如AdvertVO；反例DeleteVO；除非单纯对该对象操作，而对象具备了名词意义，比如AdvertVO中包含方法，getAccountByVO(AdvertVO advertVO) 【强制】代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式 说明: 正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，即使是纯拼音命名方式也要避免采用。 正例: alibaba / taba
超全！Python 处理日期与时间的全面总结！
Python宋宋的专栏
07-08 6102
Python的时间处理模块在日常的使用中用的较多多，但是使用的时候基本上都是要查资料，还是有些麻烦的，梳理下，便于以后方便的使用。时间相关概念Python time模块时间格式化计时器功能time模块其他内置函数time模块包含的属性datetime模块date类time类datetime类timedelta类tzinfo类pytz模块时区转换夏令时处理dateutil模块parser.parse()rrule.rrule()ArrowUTC 时间当地时间解析时间Unix 时间戳格式化日期和时间转换为区域时
JAVA经典面试题附答案(持续更新版)
hjseo_seg的博客
06-23 1万+
前言: 少年易老学难成，一寸光阴不可轻。未觉池塘春草梦，阶前梧叶已秋声 。—朱熹《劝学诗》 勤奋才是改变你命运的唯一捷径。 整理不易,各位看官点赞再看更舒适，养成好习惯(●′｀●)1.JAVA中的几种基本类型，各占用多少字节？ 下图单位是bit,非字节 1B=8bit 2.String能被继承吗？为什么？ 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”abc”(直接赋一个字面量);其实和String str=
rtsp 服务器搭建
热门推荐
yinshipin007的博客
04-07 1万+
rtsp 服务器搭建： 今天我们搭建这个 rtsp 服务器的名称叫做：ZLMediaKit，它是一个基于 C++11 的高性能运营级流媒体服务框架，类似我之前给大家搭建的 rtmp 服务器(srs 流媒体服务器)，当然它两者肯定是有区别的，这里我们就不做比较。 它也是一个开源项目，该开源项目的介绍，大家可以看官网介绍，在 github 和 gitee 都有： github 网址： https://github.com/xia-chu/ZLMediaKit 复制代码 gitee 网址： h
Python定时任务与周期任务(任务调度)
Java/Python大数据成长之路
08-27 1429
Event是APScheduler在执行任务时触发的事件，用户可以自定义一些函数来监听这些事件，当触发某些Event时(任务抛出异常后)，做一些具体操作。APScheduler包含四大组件：调度器(scheduler)，作业存储(job store)，触发器(trigger)，执行器(executor)sched是Python的标准库之一，sched是事件调度器，它通过Scheduler类来调度事件，可用于定时任务或周期任务。默认情况下调度器会等待所有正在运行的作业完成后，关闭所有的调度器和作业存储；
「Java开发指南」MyEclipse for Spring参数 - 注释器（二）
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
08-23 1078
本文将为大家介绍MyEclipse中带有Spring支持的注释器，欢迎下载最新的v2024.1版本体验！
Selenium自动化测试（IDE环境搭建）
hanxiaodihhh的博客
08-27 552
SeleniumIDE是Selenium家族的成员之一，称为Selenium集成开发环境(Integrated Development Environment )Selenium IDE最早是基于Firefox浏览器的一个插件，现在也是Chrome浏览器的一个插件SeleniumIDE结合浏览器，提供脚本录制、编辑、回放，并提供校验和验证，方便校验测试的期望值与实际值是否相符。可以使用SeleniumIDE将录制的脚本生成不同编程语言相应的带单元测试框架的自动化脚本。
【Linux】CodeServer：云IDE部署
2303_80346267的博客
08-28 491
Code-server 是一个开源项目，它允许你在任何地方通过浏览器访问 Visual Studio Code（VS Code）编辑器。这意味着你可以在远程服务器或云端运行 VS Code，并通过浏览器进行编码、调试和开发，而不需要在本地安装 VS Code。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 1961
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2327
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2539
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 755
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
最新发布
weixin_39996520的博客
08-28 533
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 362
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
zynq vivado2023.1
09-26
根据提供的引用内容，Zynq是一种设计必备的器件。Vivado 2015.4是常用且稳定的版本之一，适用于Ubuntu 14/16/18。在约束文件中，使用set_...由于提供的引用中没有关于vivado2023.1的信息，所以无法回答这一问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值