IO进程线程day6（2023.8.3）

一、Xmind整理：

进程与线程关系： 

二、课上练习：

练习1：pthread_create

功能：创建一个线程

原型：

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);

参数：

pthread_t *thread：存储创建后的线程的tid号;
pthread_attr_t *attr：线程属性; 填NULL，代表默认属性。或者用pthread_attr_init(3)初始化线程属性后 
                      传参进入：分离属性。
void *(*start_routine) (void *)：回调函数，函数指针，该函数指针指向线程执行体。
该指针可以指向返回值是void*类型，参数列表是void*类型的函数，例如：
void* handler(void* arg){                                                                                    
                        }
void *arg：传递给回调函数的参数;

返回值：

成功，返回0;
失败，返回错误编号，即非0，没说更新errno,所以不能用perror打印;

注意： 

1.从main函数进来的线程称之为主线程，pthread_create创建的线程称之为分支线程或者子线程。

2.一般来说主线程会先运行，但是还是要依照时间片轮询机制。

3.主线程退出后（main函数结束），会导致进程结束，依附于该进程内的线程均会被强制退出。

4.其他线程退出后，会不会影响到主线程。

创建一个分支线程：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
//线程的执行体
void* CallBack(void* arg)
{
    while(1)
    {
        printf("this is other fun:__%d__\n",__LINE__);
        sleep(1);
    }
    return NULL;
}
int main(int argc, const char *argv[])
{
    //创建一个分支线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,CallBack,NULL) != 0)
    {
        fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
        return -1;
    }
    while(1)
    {                                                               
        printf("this is main fun:__%d__\n",__LINE__);
        sleep(1);
    }

    return 0;
}

练习2：线程的传参 

问题1：定义一个全局变量int a=10，主线程和分支线程能否访问到，访问到的是否是同一份资源。

答案：均能访问到，且是同一份资源

问题2：在主线程定一个局部变量int b=10，分支线程能否访问到。

答案：不能，局部变量作用域在定义他的函数内部

问题3：在分支线程定义一个局部变量int c=10，主线程能否访问到。

答案：不能，局部变量作用域在定义他的函数内部

问题4：若访问不到，用什么方式可以让对方线程访问到。

i. 主线程传参给分支线程 ：

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <head.h>
 #include <pthread.h>
 //线程的执行体
 void* CallBack(void* arg)   //void* arg = (void*)&c
 {
     //void* arg使用解引用的时候，需要先强转
     //如果直接*arg,会导致操作系统不知道该访问几个字节
     while(1)
     {
         printf("this is other func c=%d\t %p__%d__\n",*(int*)arg,arg,__LINE__);
         sleep(1);
     }
     return NULL;
 }
 int main(int argc, const char *argv[])
 {                                                                               
     int c = 10;
     //创建一个分支线程
     pthread_t tid;
     if(pthread_create(&tid,NULL,CallBack,(void*)&c) != 0)
     {
         fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
         return -1;
     }
     while(1)
     {
         printf("this is other func c=%d\t %p__%d__\n",c,&c,__LINE__);
         sleep(1);
     }
     return 0;
 }

ii. 分支线程传参给主线程 ：

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <head.h>
 #include <pthread.h>
 //线程的执行体
 void* CallBack(void* arg)   //void* arg = (void*)&tmp_c
 {
     //void* arg使用解引用的时候，需要先强转
     //如果直接*arg,会导致操作系统不知道该访问几个字节
     int c = 10;
     *(int*)arg = c;        //*(int*)arg访问的就是tmp_c
     while(1)
     {
         printf("this is other func c=%d\t %p__%d__\n",c,&c,__LINE__);
         sleep(1);
     }
     return NULL;
 }
 int main(int argc, const char *argv[])
 {
     int tmp_c = -1;
     //创建一个分支线程
     pthread_t tid;
     if(pthread_create(&tid,NULL,CallBack,(void*)&tmp_c) != 0)
     {
         fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
         return -1;
     }
     while(1)                                                                    
     {
         printf("this is other func c=%d\t %p__%d__\n",tmp_c,&tmp_c,__LINE__);
         sleep(1);
     }
     return 0;
 }


 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <head.h>
 #include <pthread.h>
 //线程的执行体
 void* CallBack(void* arg)   //void* arg = (void*)&pc
 {
     //void* arg使用解引用的时候，需要先强转
     //如果直接*arg,会导致操作系统不知道该访问几个字节
     int c = 10;
 
     //由于arg存储了pc的地址，所以arg可以访问pc的内存空间
     //由于pc空间的类型为int*，所以*arg访问出来的类型也得是int*
     //所以arg类型应该是int**类型
     *(int**)arg = &c;        //*(int**)arg访问的是pc的内存空间
     while(1)
     {
         printf("this is other func c=%d\t %p__%d__\n",c,&c,__LINE__);
         sleep(1);
     }
     return NULL;
 }                                                                                 
 int main(int argc, const char *argv[])
 {
     int* pc = NULL;
     //创建一个分支线程
     pthread_t tid;
     if(pthread_create(&tid,NULL,CallBack,(void*)&pc) != 0)
     {
         fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
         return -1;
     }
     while(1)
     {
         if(pc!=NULL)
         {
             printf("this is other func c=%d\t %p__%d__\n",*pc,pc,__LINE__);
             sleep(1);
         }
     }
     return 0;
 }

练习3：pthread_exit

功能：退出分支线程，并传递线程退出状态值

原型：

#include <pthread.h>
void pthread_exit(void *retval);

参数：

 void *retval：指定要传递给主线程的状态值，如果不想传递，填NULL;
 传递的线程退出状态值被pthread_join函数接收;

当分支线程退出后，会残留一部分资源，例如线程的tid号，线程调度块等等，若不回收会出现类似僵尸线程的状态;

需要使用pthread_join等函数回收；

练习4：pthread_join

功能：阻塞函数，阻塞等待指定的分支线程退出，并接收分支线程退出状态值，

           同时回收分支线程的资源

原型：

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

参数：

pthread_t thread：指定要等待哪个线程，填对应的tid号;
void **retval：若retval不为空，则该函数会将线程退出状态值（void* retval）拷贝到该二级指针指向的一级指针的内存空间中，
若不想接收填NULL;
If retval is not NULL, then pthread_join() copies  the  exit
status of the target thread  into  the   location pointed  to  by  retval.

返回值：

成功，返回0;
失败，返回错误编号，即非0，没说更新errno,所以不能用perror打印;

小练1：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
//线程的执行体
void* CallBack(void* arg)   //void* arg = NULL
{
    int i = 0;
    while(i<3)
    {
        printf("this is other func:__%d__\n",__LINE__);
        sleep(1);
        i++;
    }
    pthread_exit(NULL);     //专门用于退出线程
    printf("退出分支线程\n");
    return NULL;
}

int main(int argc, const char *argv[])
{
    //创建一个分支线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,CallBack,NULL) != 0)
    {
        fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
        return -1;
    }                                                                     
    printf("this is main func  __%d__\n",__LINE__);
    pthread_join(tid,NULL);  //阻塞等待tid分支线程退出
    printf("主线线程准备退出\n");
    return 0;
}

小练2： 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
//线程的执行体
void* CallBack(void* arg)   //void* arg = NULL
{
    int i=0;
    while(i<3)
    {
        printf("this is other fun:__%d__\n",__LINE__);
        sleep(1);
        i++;
    }

    printf("分支线程准备退出\n");
    static int a =10;    //延长生命周期，防止线程退出后被释放
    printf("&a = %p\n",&a);
    pthread_exit(&a);    //void* retval = &a;
                                                                       
}

int main(int argc, const char *argv[])
{
    //创建一个分支线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,CallBack,NULL) != 0)
    {
        fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
        return -1;
    }
    printf("this is main func  __%d__\n",__LINE__);
    //线程退出状态值会被拷贝到&pret指向的一级指针(pret)中
    //即 pret=&a;
    void* pret=NULL;
    pthread_join(tid,&pret);       //阻塞等待tid分支线程退出
    printf("pret = %d %p\n",*(int*)pret,pret);
    printf("主线线程准备退出\n");
    return 0;
}

小练3：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
//线程的执行体
void* CallBack(void* arg)   //void* arg = NULL
{
    int i=0;
    while(i<3)
    {
        printf("this is other fun:__%d__\n",__LINE__);
        sleep(1);
        i++;
    }

    printf("分支线程准备退出\n");
    char* ptr = (char*)malloc(12);                                  
    strcpy(ptr,"hello world");
    pthread_exit(ptr);
}

int main(int argc, const char *argv[])
{
    //创建一个分支线程
    pthread_t tid;
    if(pthread_create(&tid,NULL,CallBack,NULL) != 0)
    {
        fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
        return -1;
    }
    printf("this is main func  __%d__\n",__LINE__);

    //线程退出状态值会被拷贝到&ptr指向的一级指针(pret)中
    //即pret = ptr;
    void* pret = NULL;
    pthread_join(tid,&pret);
    printf("%s\n",(char*)pret);
    free(pret);
    printf("主线线程准备退出\n");
    return 0;
}

练习5：创建两个线程：其中一个线程拷贝前半部分，另一个线程拷贝后半部分。

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <head.h>
 #include <pthread.h>
 
 //拷贝前半部分
 void* CallBack1(void* arg)
 {
     //以读的方式打开源文件
     int fd_r = open("./1.png",O_RDONLY);
     if(fd_r < 0)
     {
         ERR_MSG("open");
         return NULL;
     }
     //以写的方式打开目标文件
     int fd_w = open("./2.png",O_WRONLY);
     if(fd_w < 0)
     {
         ERR_MSG("open");
         return NULL;
     }
     off_t size = lseek(fd_r,0,SEEK_END);
 
     //修改文件偏移量到文件开头位置
     lseek(fd_r,0,SEEK_SET);
     lseek(fd_w,0,SEEK_SET);
     char c=0;
     for(int i=0;i<size/2;i++)
     {
         read(fd_r,&c,1);
         write(fd_w,&c,1);
     }
     printf("前半部分拷贝完毕\n");
     //关闭文件
     close(fd_r);
     close(fd_w);
     pthread_exit(NULL);
 }
 //拷贝后半部分
 void* CallBack2(void* arg)     //void* arg=&fileinfo
 {
     //以读的方式打开源文件
     int fd_r = open("./1.png",O_RDONLY);
     if(fd_r < 0)
     {
         ERR_MSG("open");
         return NULL;
     }
     //以写的方式打开目标文件
     int fd_w = open("./2.png",O_WRONLY,0664);
     if(fd_w < 0)
     {
         ERR_MSG("open");
         return NULL;
     }
     off_t size = lseek(fd_r,0,SEEK_END);
 
     //修改文件偏移量到文件开头位置
     lseek(fd_r,size/2,SEEK_SET);
     lseek(fd_w,size/2,SEEK_SET);
     char c=0;
     for(int i=size/2;i<size;i++)
     {
         read(fd_r,&c,1);
         write(fd_w,&c,1);
     }
     printf("后半部分拷贝完毕\n");
     //关闭文件
     close(fd_r);
     close(fd_w);
     pthread_exit(NULL);
 }
 
 int main(int argc, const char *argv[])
 {
     //两个线程在拷贝前，确保文件存在，且是清空状态
     int fd_w = open("./2.png",O_WRONLY|O_CREAT|O_TRUNC,0664);
     if(fd_w < 0)                                                                          
     {
         ERR_MSG("open");
         return -1;
     }
     close(fd_w);
 
     //创建一个线程
     pthread_t tid1,tid2;
     if(pthread_create(&tid1,NULL,CallBack1,NULL) != 0)
     {
         fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
         return -1;
     }
     if(pthread_create(&tid2,NULL,CallBack2,NULL) != 0)
     {
         fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
         return -1;
     }
 
     //阻塞等待分支线程退出
     pthread_join(tid2,NULL);
     pthread_join(tid1,NULL);
 
 
     return 0;
 }

练习6：pthread_detach

功能：分离线程，线程退出后资源由系统自动回收

原型：

#include <pthread.h>
int pthread_detach(pthread_t thread);

参数：

 pthread_t thread：指定要分离哪个线程;

返回值：

成功，返回0;
失败，返回错误编号，即非0，没说更新errno,所以不能用perror打印;

注意：当使用pthread_detach分离tid线程后，pthread_join函数就无法再回收tid线程的资源了，且pthread_join函数不阻塞！

练习7：pthread_cancel

功能：请求指定线程退出; 请求成功，对方线程不一定退出

原型：

#include <pthread.h>
int pthread_cancel(pthread_t thread);

参数：

 pthread_t thread：指定要请求哪个线程退出;

返回值：

成功，返回0;
失败，返回错误编号，即非0，没说更新errno,所以不能用perror打印;
1.pthread_cancel会给目标线程打上一个退出标识，cpu切换到目标线程后，运行到退出标识，才会让目标线程退出。

2.但是while for 等循环结构，以及算数运算等等位置，无法打上退出标识。所以当目标线程只有上述结构的时候，无法用pthread_cancel退出线程

3.printf ,sleep等等函数结构可以打上退出标识

4.请求成功，不代表目标线程一定会退出。

练习8：要求定义一个全局变量 char buf[] = "1234567"，创建两个线程，不考虑退出条件。

①A线程循环打印buf字符串

②B线程循环倒置buf字符串，即buf中本来存储1234567，倒置后buf中存储7654321. 不打印！！

③倒置不允许使用辅助数组。

④要求A线程打印出来的结果只能为 1234567 或者 7654321 不允许出现7634521 7234567

⑤不允许使用sleep函数

#include <stdio.h>
#include <pthread.h>
#include <string.h>

char buf[] = "1234567";
int flag = 0;

void* callBack1(void* arg)
{
    while(1)
    {
        if(0 == flag)
        {
            printf("%s\n", buf);
            flag = 1;
        }
    }
    pthread_exit(NULL);
}

void* callBack2(void* arg)
{
    char tmp = 0;
    while(1)                                                                               
    {
        if(1 == flag)
        {
            for(int i=0; i<strlen(buf)/2; i++)
            {
                tmp = buf[i];
                buf[i] = buf[strlen(buf)-1-i];
                buf[strlen(buf)-1-i] = tmp;
            }
            flag = 0;
        }
    }

    pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
    pthread_t tid1, tid2;
    if(pthread_create(&tid1, NULL, callBack1, NULL) != 0)
    {
        fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
        return -1;
    }
    pthread_detach(tid1);   //分离线程1

    if(pthread_create(&tid2, NULL, callBack2, NULL) != 0)
    {
        fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
        return -1;
    }

    pthread_join(tid2, NULL);   //阻塞等待线程2退出

    return 0;
}

练习9：pthread_mutex_init

功能：创建一个互斥锁

原型：

#include <pthread.h>
pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
int pthread_mutex_init(pthread_mutex_t *mutex, const
pthread_mutexattr_t *mutexattr);

参数：

pthread_mutex_t *mutex：存储申请后的互斥锁;
const pthread_mutexattr_t *mutexattr：互斥锁属性，设置互斥锁适用于进程间还是线程间的同步互斥锁。
                                      填NULL，默认属性，用于线程

返回值：

永远成功，返回0；

练习10：pthread_mutex_lock

功能：对互斥锁进行上锁，若有其他线程占用互斥锁，该函数会阻塞

原型：

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);

参数：

pthread_mutex_t *mutex;

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

练习11：pthread_mutex_unlock

功能：解开互斥锁

原型：

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

pthread_mutex_t *mutex;

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

练习12：pthread_mutex_destroy

功能：销毁互斥锁

原型：

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

pthread_mutex_t *mutex;

返回值：

成功，返回0;
失败，返回非0，没有说更新errno，所以不要用perror打印错误。

小练： 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <pthread.h>
//临界资源
char buf[]="1234567";

//互斥锁
pthread_mutex_t mutex;

void* CallBack1(void* arg)
{
    while(1)
    {
        /**********临界区*********/
        //上锁
        pthread_mutex_lock(&mutex);
        printf("%s\n",buf);
        //解锁
        pthread_mutex_unlock(&mutex);
        /**********临界区*********/
    }
    pthread_exit(NULL);
}
void* CallBack2(void* arg)
{
    char tmp=0;
    while(1)
    {
        /**********临界区*********/
        //上锁                                                              
        pthread_mutex_lock(&mutex);
        for(int i=0;i<strlen(buf)/2;i++)
        {
            tmp=buf[i];
            buf[i]=buf[strlen(buf)-1-i];
            buf[strlen(buf)-1-i]=tmp;
        }
        //解锁
        pthread_mutex_unlock(&mutex);
        /**********临界区*********/
    }
    pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
    //申请一个互斥锁
    pthread_mutex_init(&mutex,NULL);

    pthread_t tid1,tid2;
    if(pthread_create(&tid1,NULL,CallBack1,NULL) != 0)
    {
        fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
        return -1;
    }
    pthread_detach(tid1);  //分离线程1
        if(pthread_create(&tid2,NULL,CallBack2,NULL) != 0)
        {
            fprintf(stderr,"pthread_create failed:__%d__\n",__LINE__);
            return -1;
        }

    pthread_join(tid2,NULL);        //阻塞等待线程2退出

    //销毁互斥锁
    pthread_mutex_destroy(&mutex);

    return 0;
}

三、课后作业：

1.创建两个线程：其中一个线程拷贝前半部分，另一个线程拷贝后半部分。

   只允许开一份资源，且用互斥锁方式实现。 提示：找临界区--->找临界资源。

#include <stdio.h>
#include <pthread.h>
#include <head.h>
 
//创建互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
struct Msg
{
	int fd_r;
	int fd_w;
	off_t size;
};
void *callBack1(void *arg)
{
	int fd_r = ((struct Msg *)arg)->fd_r;
	int fd_w = ((struct Msg *)arg)->fd_w;
	off_t size = ((struct Msg *)arg)->size;
	char c;
 
    //上锁
	pthread_mutex_lock(&mutex);
	lseek(fd_r,0,SEEK_SET);
	lseek(fd_w,0,SEEK_SET);
	for(int i = 0;i<size/2;i++)
	{
		read(fd_r,&c,1);
		write(fd_w,&c,1);
	}
    //解锁
	pthread_mutex_unlock(&mutex);
 
	pthread_exit(NULL);
}
void *callBack2(void *arg)
{
	int fd_r = ((struct Msg *)arg)->fd_r;
	int fd_w = ((struct Msg *)arg)->fd_w;
	off_t size = ((struct Msg *)arg)->size;
	char c;
	
    //上锁
	pthread_mutex_lock(&mutex);
	lseek(fd_r,size/2,SEEK_SET);
	lseek(fd_w,size/2,SEEK_SET);
	for(int i=size/2;i<size;i++)
	{
		read(fd_r,&c,1);
		write(fd_w,&c,1);
	}
    //解锁
	pthread_mutex_unlock(&mutex);
 
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	int fd_r = open("./1.png",O_RDONLY);
	if(fd_r < 0)
	{
		perror("open");
		return -1;
	}
	int fd_w = open("./2.png",O_WRONLY|O_CREAT|O_TRUNC,0664);
	if(fd_w < 0)
	{
		perror("open");
		return -1;
	}
	off_t size = lseek(fd_r,0,SEEK_END);
	struct Msg Copy;
	Copy.fd_r = fd_r;
	Copy.fd_w = fd_w;
	Copy.size = size;
 
	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,callBack1,&Copy) != 0)
	{
		fprintf(stderr,"pthread_create failed __%d__",__LINE__);
		return -1;
	}
	if(pthread_create(&tid2,NULL,callBack2,&Copy) != 0)
	{
		fprintf(stderr,"pthread_create failed __%d__",__LINE__);
		return -1;
	}
 
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
 
	pthread_mutex_destroy(&mutex);
	close(fd_r);
	close(fd_w);
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/57746.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Unity学习笔记】生命周期

【Unity学习笔记】生命周期

文章目录 脚本的生命周期初始化更新顺序动画更新循环各类事件结束阶段 阶段分析协程返回 总结 官方文档&#xff1a;事件函数的执行顺序 脚本的生命周期 如图&#xff1a; 脚本的生命周期主要经历以下几个阶段&#xff1a; 初始化 初始化阶段&#xff0c;&#xff08;包括初…
阅读更多...
JVM之内存结构

JVM之内存结构

1.程序计数器 定义&#xff1a;程序计数器&#xff08;Program Counter Register&#xff09;是JVM中一块较小的内存空间。解释器在解释JVM指令为机器码以供CPU执行时&#xff0c;会去程序计数器当中找到jvm指令的执行地址。 作用&#xff1a;记住下一条jvm指令的执行地址 特…
阅读更多...
机器学习笔记 - 使用 YOLOv5、O​​penCV、Python 和 C++ 检测物体

机器学习笔记 - 使用 YOLOv5、O​​penCV、Python 和 C++ 检测物体

一、YOLO v5简述 YOLO v5虽然已经不是最先进的对象检测器，但是YOLOv5 使用了一个简单的卷积神经网络 CNN架构（相对YOLO v8来讲，不过v8精度是更高了一些），更易理解。这里主要介绍如何轻松使用 YOLO v5来识别图像中的对象。将使用 OpenCV、Python 和 C++ 来加载和调用我们的…
阅读更多...
CPU缓存那些事儿

CPU缓存那些事儿

CPU缓存那些事儿 CPU高速缓存集成于CPU的内部&#xff0c;其是CPU可以高效运行的成分之一&#xff0c;本文围绕下面三个话题来讲解CPU缓存的作用&#xff1a; 为什么需要高速缓存&#xff1f;高速缓存的内部结构是怎样的&#xff1f;如何利用好cache&#xff0c;优化代码执行…
阅读更多...
Go学习第三天

Go学习第三天

map的三种声明定义方式 声明map后&#xff0c;一定要make开辟空间&#xff0c;否则会报越界且不能使用 package mainimport "fmt"func main() {// 第一种声明方式// 声明myMap1是一种map类型 key是string value是stringvar myMap1 map[string]string// 判断一下map在…
阅读更多...
小研究 - 微服务系统服务依赖发现技术综述（二）

小研究 - 微服务系统服务依赖发现技术综述（二）

微服务架构得到了广泛的部署与应用, 提升了软件系统开发的效率, 降低了系统更新与维护的成本, 提高了系统的可扩展性. 但微服务变更频繁、异构融合等特点使得微服务故障频发、其故障传播快且影响大, 同时微服务间复杂的调用依赖关系或逻辑依赖关系又使得其故障难以被及时、准确…
阅读更多...
木马病毒怎么回事？带你深度分析了解木马病毒！

木马病毒怎么回事？带你深度分析了解木马病毒！

一、病毒简介 SHA256:3110f00c1c48bbba24931042657a21c55e9a07d2ef315c2eae0a422234623194 MD5:ae986dd436082fb9a7fec397c8b6e717 SHA1:31a0168eb814b0d0753f88f6a766c04512b6ef03 二、行为分析 老套路&#xff0c;火绒剑监控&#xff1a; 这边可以看见创建了一个exe&#x…
阅读更多...
性能压力测试的重要性与实施方法

性能压力测试的重要性与实施方法

性能压力测试是在软件开发过程中评估系统在不同负载条件下的表现和稳定性的关键步骤。这种测试是为了确定系统在正常和峰值负载下的性能表现&#xff0c;以验证系统是否能够满足用户需求&#xff0c;同时发现潜在的性能问题并加以解决。 首先&#xff0c;性能压力测试对于确保系…
阅读更多...
《皮囊》阅读笔记

《皮囊》阅读笔记

《皮囊》阅读笔记 2023年8月2号在杭州小屋读完&#xff0c;该书共收录14篇散文&#xff0c;内容大致分为两部分&#xff1a;前半部分讲述作者的阿太&#xff08;外婆的母亲&#xff09;、母亲、父亲关于生活哲学、房子、疾病与信仰的故事&#xff0c;后半部分讲述生活在小镇的张…
阅读更多...
【BASH】回顾与知识点梳理（一）

【BASH】回顾与知识点梳理（一）

【BASH】回顾与知识点梳理 一 前言一. 认识与学习 BASH1.1 硬件、核心与 Shell1.2 为何要学文字接口的 shell&#xff1f;1.3 系统的合法 shell 与 /etc/shells 功能1.4 Bash shell 的功能1.5 查询指令是否为 Bash shell 的内建命令&#xff1a; type1.6 指令的下达与快速编辑按…
阅读更多...
122.买卖股票的最佳时机2

122.买卖股票的最佳时机2

一、题目 122. 买卖股票的最佳时机 II - 力扣&#xff08;LeetCode&#xff09; 二、代码 class Solution { public:int maxProfit(vector<int>& prices) {int n prices.size();vector<vector<int>>dp(n,vector<int>(2,0));//0表示第i天不持有股…
阅读更多...
python算法指南程序员经典,python算法教程pdf百度云

python算法指南程序员经典,python算法教程pdf百度云

大家好&#xff0c;小编来为大家解答以下问题&#xff0c;你也能看懂的python算法书 pdf&#xff0c;python算法教程这本书怎么样&#xff0c;现在让我们一起来看看吧&#xff01; 给大家带来的一篇关于算法相关的电子书资源&#xff0c;介绍了关于算法、详解、算法基础方面的内…
阅读更多...
最细致讲解yolov8模型推理完整代码--（前处理，后处理）

最细致讲解yolov8模型推理完整代码--（前处理，后处理）

研究yolov8时&#xff0c;一直苦寻不到Yolov8完整的模型推理代码演示&#xff0c;大部分人都是基于Yolo已经封装好的函数调用&#xff0c;这个网上教程很多&#xff0c;本文就不赘述这方面的内容了&#xff0c;接下来将细致全面的讲解yolov8模型推理代码&#xff0c;也就是yolo…
阅读更多...
cloudstack远程调试

cloudstack远程调试

前置条件&#xff1a;服务器安装好cloudstack的management、agent; 1、managemeng、agent启动服务文件 packaging/systemd cloudstack-agent.default # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTIC…
阅读更多...
ES6之Promise、Class类与模块化（Modules）

ES6之Promise、Class类与模块化（Modules）

目录 PromiseClass类extendssuper Modules 模块系统export default 和对应importexport 和 import Promise Promise 是 ES6 引入的一种用于处理异步操作的对象。 它解决了传统回调函数&#xff08;callback&#xff09;模式中容易出现的回调地狱和代码可读性差的问题。 Promis…
阅读更多...
数学学习——最优化问题引入、凸集、凸函数、凸优化、梯度、Jacobi矩阵、Hessian矩阵

数学学习——最优化问题引入、凸集、凸函数、凸优化、梯度、Jacobi矩阵、Hessian矩阵

文章目录 最优化问题引入凸集凸函数凸优化梯度Jacobi矩阵Hessian矩阵 最优化问题引入 例如&#xff1a;有一根绳子&#xff0c;长度一定的情况下&#xff0c;需要如何围成一个面积最大的图像&#xff1f;这就是一个最优化的问题。就是我们高中数学中最常见的最值问题。 最优化…
阅读更多...
小白到运维工程师自学之路 第六十五集 （docker-compose）

小白到运维工程师自学之路 第六十五集 （docker-compose）

一、概述 Docker Compose 的前身是 Fig&#xff0c;它是一个定义及运行多个 Docker 容器的工具。可以使用YAML文件来配置应用程序的服务。然后&#xff0c;使用单个命令&#xff0c;您可以创建并启动配置中的所有服务。Docker Compose 会通过解析容器间的依赖关系&#xff08;…
阅读更多...
vmware网络配置

vmware网络配置

效果&#xff1a; 虚拟机和物理机网络互通&#xff1b; 虚拟机可以上外网 环境&#xff1a; vmware version 17.0.0 Centos 7.9 配置 1&#xff0c;vmware 菜单 - 编辑 - Virtual Network Edit 2&#xff0c; 选择VMnet8 VMnet information:NAT&#xff1b; 勾选2个…
阅读更多...
ansible控制主机和受控主机之间免密及提权案例

ansible控制主机和受控主机之间免密及提权案例

目录 案例描述 环境准备 案例一--免密远程控制主机 效果展示&#xff1a; 解决方案 1.添加主机 2.通过ssh-key生成密钥对 3.生成ssh-copy-id 4.验证 案例二-----免密普通用户提权 效果展示 解决方案 1.使用普通用户&#xff0c;与案例一 一样&#xff0c;进行发送密钥…
阅读更多...
【力扣每日一题】2023.8.2 翻转卡片游戏

【力扣每日一题】2023.8.2 翻转卡片游戏

目录 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 代码&#xff1a; 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 这道题不是什么翻转卡片游戏&#xff0c;这就是纯纯的文字游戏&#xff0c;要是能看懂题目那就是非常简单&#xff0c;接下来我就给大家分…
阅读更多...
最新文章

Copyright @ 2022~2023