05-系统编程（线程）

最新推荐文章于 2024-06-05 15:16:22 发布
最新推荐文章于 2024-06-05 15:16:22 发布
阅读量44 收藏
点赞数
文章标签： 算法 c语言 嵌入式实时数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79475863/article/details/133675348
版权

05-线程

文章目录

一、linux最小资源单位 – 线程

1.线程与进程
进程： 进程是操作系统资源分配的基本实体
线程： 线程是CPU调度的基本单位，是进程内部资源，是linux中最小资源单位。（填空选择）
int main(int argc,char argv[])
{
//单进程
/ 进程开始 */
…;
…; -> 在进程运行过程中，可以创建出多个线程。
…;

/* 进程结束 */
return 0;

}
假设linux是一个社会，进程就是一个车间，线程就是车间里面的各个工人。

2.线程函数接口特点？
1）由于线程函数接口都是封装在一个线程库，所以我们是看不到源码的，查看线程的函数，都是在第3手册： man 3 xxxx
2）所有线程函数的头文件：#include <pthread.h>

二、线程的函数接口

1.创建一个子线程 -> pthread_create()

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
函数参数：
thread：储存线程ID号的变量的地址 pthread_t -> 线程ID号的数据类型
attr：线程的属性，普通属性填NULL
start_routine：线程的执行函数。该线程需要做什么任务，就写到这个函数中函数必须是:void *fun(void *arg) 回调函数–>函数指针
arg：传递给子线程的参数(任意指针类型)
返回值：
成功：0
失败：非0错误码
注意：Compile and link with -pthread. 只要你的程序设计到线程的函数，在编译时必须链接线程库
编译命令： gcc xxx.c -o xxx -lpthread（编译线程的时候一定要加线程库）
说明：
1.在子线程理论上可以创建无数条子线程
2.主线程与子线程是并发运行，没有时间先后之分
3.主线程结束表示整个进程结束;包括子线程也结束。

  1. 函数指针与回调函数
    void *(*start_routine) (void *)
    它是一个函数指针类型，指针指向的是一个函数，函数的返回值是void *;函数的参数是void *
    typedef void (*sighandler_t)(int); //函数指针
    自定义了一个函数指针类型，指针指向一个函数，函数的返回值是void;函数的参数是int;
    给这个函数指针类型取了一个别名，名字叫做sighandler_t

代码解释：

#include <stdio.h>

int fun(int a, int b)
{
    printf("a+b=%d\n", a + b);
}

/*
    __LINE__:行号
    __FUNCTION__:函数名
*/
void *fun2(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);
    return NULL;
}

// 给自定义的函数指针类型取了一个别名 名字叫做bling
typedef int (*bling1)(int, int);

int main()
{
    /*
        //1.函数指针
        //2.指针指向的是一个函数
        //3.函数的参数是两个int类型
        //4.参数的返回值是一个int
    */

    // 给函数指针定义+初始化
    int (*bling)(int, int) = fun; // 常用的写法
    //  int (*bling)(int, int) = &fun;

    // 先定义再初始化
    //  int (*bling)(int, int);
    //  bling = fun;

    // 调用函数
    //  fun(3,4); //常规直接调用

    // 通过函数指针来调用函数
    bling(5, 6); // 常用的写法
    // (*bling)(5,6); //等价于(*&fun)(5,6)==fun(5,6)

    /*
        通过别名来定义函数指针变量
    */
    bling1 b1 = fun; // 常用写法
    b1(7, 8);

    // 非常用写法
    //  bling1 b1 = &fun;
    //  (*b1)(7,8);

    /*
        这种类型的函数指针
        void *(*bling2)(void *)
    */
    void *(*bling2)(void *) = fun2;
    // (void *)(*bling2)(void *) = fun2;  //不要给返回值加括号 错误
    bling2(NULL);

    return 0;
}

2）线程同时干不同的事
例子： 尝试创建一个新的线程，看看能不能同时做两件事情

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

//线程例程，创建一条线程之后，去执行这个函数
void* start_routine(void *arg)
{
    while(1)
    {
        sleep(1);
        printf("start_routine\n");
    }
    
} 
int main()
{
    //创建一条线程
    pthread_t thread;
    pthread_create(&thread,NULL,start_routine,NULL);
    
    while(1)
    {
        sleep(1);
        printf("main\n");
    }
    return 0;
}

验证一个进程最多能创建几条线程：

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

/*
    单进程
*/

//子线程start_routine1
void *start_routine1(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    while(1)
    {
        printf("我爱坤坤.....\n");
        sleep(1);
    }
}

//子线程start_routine2
void *start_routine2(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    while(1)
    {
        printf("我是ikun.....\n");
        sleep(1);
    }
}

int main()
{
    /*
        主线程
    */

    //创建一个子线程
    int ret = 0;
    pthread_t tid; //不要定义成pthread_t *tid
    ret = pthread_create(&tid,NULL,start_routine1,NULL);
    if(ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    //创建一个子线程
    pthread_t tid1; //不要定义成pthread_t *tid
    ret = pthread_create(&tid1,NULL,start_routine2,NULL);
    if(ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    //普通的函数调用
    // start_routine2(NULL);

    // pause();
    while(1)
    {
        printf("坤坤打篮球.....\n");
        sleep(1);     
    }

    return 0;
}

3）线程的传参
struct st
{
char name[20];
char sex;
int height;
float score;
}
使用线程将一个学生信息传递给子线程，然后在子线程中打印该学生的信息。

代码说明：

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

// 子线程fun1   ---char类型
void *fun1(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    // 拿传参的值
    // 1.类型转换
    // 2.解引用
    char c = *((char *)arg);
    printf("arg char:%c\n", c);
}

// 子线程fun2   ---- int类型
void *fun2(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    // 拿传参的值
    // 1.类型转换
    // 2.解引用
    int num = *(int *)arg;
    printf("arg int:%d\n", num);
}

// 子线程fun3--- int *指针
void *fun3(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    // 拿传参的值
    // 1.类型转换
    // 2.解引用
    int num = *(int *)arg;
    printf("arg int *:%d\n", num);
}

// 子线程fun4----char * 字符串
void *fun4(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    // 拿传参的值
    // 1.类型转换
    // 2.解引用
    printf("arg char *:%s\n", (char *)arg);
}

// 子线程fun5-----int arr[2]
void *fun5(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    // 拿传参的值
    // 1.类型转换
    // 2.解引用
    int *arr = (int *)arg;

    // printf("arg int [2]:%d %d\n",*arr,*(arr+1));
    printf("arg int [2]:%d %d\n", arr[0], arr[1]);
}

int main()
{

    int ret = 0;
    /*
        传参 :char类型
    */
    char c = 'a';
    pthread_t tid1;
    //&c--> char * 类型转换
    ret = pthread_create(&tid1, NULL, fun1, (void *)&c); // 刚开始的时候建议这么写
    // ret = pthread_create(&tid1,NULL,fun1,&c); //char *是void *类型中一种
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    /*
        传参 :int类型
    */
    int num = 250;
    pthread_t tid2;
    //&num--> int * 类型转换
    ret = pthread_create(&tid2, NULL, fun2, (void *)&num); // 刚开始的时候建议这么写
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    /*
        传参 :指针类型
    */
    int val = 300;
    // int *p = &val; //指针p获得是栈空间
    int *p = malloc(sizeof(int)); // 堆空间
    *p = 350;
    pthread_t tid3;
    ret = pthread_create(&tid3, NULL, fun3, (void *)p); // 刚开始的时候建议这么写
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    /*
        传参 :字符串类型 char *
    */
    char *str = "合班6 牛逼";
    pthread_t tid4;
    ret = pthread_create(&tid4, NULL, fun4, (void *)str);
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    /*
        传参:数组
    */
    int arr[2] = {3, 4};
    pthread_t tid5;
    ret = pthread_create(&tid5, NULL, fun5, (void *)arr);
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    // while (1);
    pthread_jpin(tid1, NULL);
    pthread_jpin(tid2, NULL);
    pthread_jpin(tid3, NULL);
    pthread_jpin(tid4, NULL);
    pthread_jpin(tid5, NULL);

    return 0;
}

2、接合一条线程 （阻塞等待子线程的退出） -> pthread_join()

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
参数：
thread：需要接合的线程的ID号
retval：储存子线程的退出值指针，如果填NULL，代表不关心子线程的退出状态。
返回值：
成功：0
失败：非0

例子：

情况一：
主线程工作时间长，才去join()。 -> pthread_join()会马上返回。
子线程工作时间短，早就结束。
情况二：
主线程工作时间短，早去join()。 -> pthread_join()会阻塞等待子线程的退出。
子线程工作时间长。

代码参考：

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

//线程例程，创建一条线程之后，去执行这个函数
void* start_routine(void *arg)
{
    sleep(5);
    printf("start_routine\n");  
} 

int main()
{
    //创建一条线程
    pthread_t thread;
    pthread_create(&thread,NULL,start_routine,NULL);
    
    //sleep(1);
    printf("main\n");
    
    //等待子线程退出
    pthread_join(thread,NULL);
    
    return 0;
}

说明：
printf(“[%s][%d]num = %d\n”,FUNCTION,LINE,*((int *)arg));
利用__FUNCTION__和__LINE__可以区分子线程和主线程的打印

代码说明：

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

/*
    单进程
*/

//子线程start_routine1
void *start_routine1(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    int cnt = 10;
    while(cnt--)
    {
        printf("我爱坤坤.....%d\n",cnt);
        sleep(1);     
    }

}

int main()
{
    /*
        主线程
    */

    //创建一个子线程
    int ret = 0;
    pthread_t tid; //不要定义成pthread_t *tid
    ret = pthread_create(&tid,NULL,start_routine1,NULL);
    if(ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    int cnt = 5;
    while(cnt--)
    {
        printf("我是ikun.....%d\n",cnt);
        sleep(1);     
    }

    //主线程结合子线程(阻塞等待子线程的退出)
    ret = pthread_join(tid,NULL); //类比wait(NULL)
    if(ret != 0)
    {
        perror("pthread_join fail");
    }
    perror("pthread_join success");

    return 0;
}

3、退出线程 -> pthread_exit()

#include <pthread.h>
void pthread_exit(void *retval);
函数作用：
子线程主动结束退出
参数：
retval：子线程退出值变量的地址 -> 这个退出值必须是全局变量（或者是堆）
说明：
不能将遗言存放到线程的局部变量里，因为如果用户写的线程函数退出了，
线程函数栈上的局部变量可能就不复存在了。（函数结束栈空间）

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

int pthread_status = 10;//线程的退出变量 必须存在数据段中

//线程例程
void* start_routine(void*arg)
{
    /* int cnt=10;
    while(cnt--)
    {
        sleep(1);
        printf("start_routine arg：%d cnt:%d\n",*((int*)arg),cnt);
    } */
    printf("start_routine\n");
    //子线程主动退出
    pthread_exit(&pthread_status);

    printf("3333\n");
}

int main()
{
    //只有一条（PCB结构体只有一个）线程的主进程 
    //主线程 
    printf("main start.....\n");
    int val = 100;
    int ret;
    //创建一条子线程（申请一个内核 PCB任务结构体）,执行任务（线程例程，说白了创建这条线程之后，去执行一个函数）
    pthread_t thread;      
    ret = pthread_create(&thread,NULL,start_routine, &val);
    if(ret != 0){
        printf("pthread_create error\n");
    }

    /* int cnt=20;
    while(cnt--){
    sleep(1);
    printf("主线程 正在执行任务%d....\n",cnt);
    } */

    //阻塞等待子进程的退出
    pthread_join(thread,NULL);
    void *retval = NULL; //void *retval = &pthread_status;//重点写法
    pthread_join(thread,&retval); //pthread_join(pthread_tthread,void**retval);
    printf("阻塞等待子线程[%lu]的退出 成功 退出值为:%d\n",thread,*(int*)retval);

    //进程结束
    printf("main end.......\n");
    return 0;
}
导致线程退出的因素：
 The new thread terminates in one of the following ways:
//以下这几种情况之一都可以导致线程退出
       * It calls pthread_exit(3), specifying an exit status value that is available to another thread in the  same  process  that  calls pthread_join(3).
//1）当线程调用了pthread_exit(),还可以将退出值返回给那个接合的它的线程。
       * It returns from start_routine().  This is equivalent to calling pthread_exit(3) with the value supplied in the return statement.
//2）当例程函数返回时，也可以导致线程的退出，return后面的值就是退出值。
       * It is canceled (see pthread_cancel(3)).
//3）收到取消请求。
       * Any  of the threads in the process calls exit(3), or the main thread performs a return from main().  This causes the termination of all threads in the process.
//4）任意一个线程调用exit()，都会导致所有的线程都退出/main函数返回

代码说明：

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

/*
    单进程
*/

int val = 250; // 全局变量---数据段中 ok

// 子线程start_routine1
void *start_routine1(void *arg)
{
    // int val = 250; //占空间不ok

    // int *p = malloc(4); //堆空间也ok
    // *p = 250;
    // pthread_exit((void *)p); 

    printf("[%d][%s]\n", __LINE__, __FUNCTION__);

    int cnt = 1;
    while (cnt--)
    {
        printf("我爱坤坤.....%d\n", cnt);
        sleep(1);
    }

    // 线程的退出(如果不需要子线程的退出值,可以不写)
    pthread_exit(NULL);  //常用写法

    // 退出的全局变量
    // pthread_exit((void *)&val); //&val-->int *

    // 子线程退出一个自己的值"886"
    //"886"字符串常量--->.raodata----->数据段
    //pthread_exit((void *)"886"); // char *类型

    // 子线程退出一个自己的值"1" 模拟return 1的写法
    //"1"字符串常量--->.raodata----->数据段
    // pthread_exit((void *)"1"); // char *类型

    // exit(0); //慎用
}

int main()
{
    /*
        主线程
    */

    // 创建一个子线程
    int ret = 0;
    pthread_t tid; // 不要定义成pthread_t *tid
    ret = pthread_create(&tid, NULL, start_routine1, NULL);
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    int cnt = 1;
    while (cnt--)
    {
        printf("我是ikun.....%d\n", cnt);
        sleep(1);
    }

    // 主线程结合子线程不关心子线程的退出值(阻塞等待子线程的退出)
    //  ret = pthread_join(tid,NULL); //类比wait(NULL) 常用写法
    //  if(ret != 0)
    //  {
    //      perror("pthread_join fail");
    //  }
    //  perror("pthread_join success");

    // int pthread_join(pthread_t thread, void **retval);
    // 主线程结合子线程关心子线程的退出值(阻塞等待子线程的退出)

    void *retval = NULL; // 不要定义成void **retval
    //&retval的类型就是void **类型
    ret = pthread_join(tid, &retval); // retval指针是通过函数pthread_join给它空间
    if (ret != 0)
    {
        perror("pthread_join fail");
    }
    // 此处接收的是全变变量 int val=250
    printf("pthread_join success retval:%d\n",*(int*)retval); //如果retval没有空间的一定会段错误(段错误的原因就是访问空指针)

    // 此处接收的是常量"886"
    // printf("pthread_join success retval:%s\n", (char *)retval);

    //此处接收的是常量"1"
    // int ret1 = atoi((char *)retval);
    // printf("pthread_join success retval:%d\n", atoi((char *)retval) );
    // if(ret1 == 1)
    // {
    //     printf("ok\n");
    // }
    // if(strcmp((char *)retval,"1") == 0)
    // {
    //     printf("ook\n");
    // }


    return 0;
}

三、主线程与子线程之间的通信方式

主线程与子线程之间互相通信有哪几种方式：
1.主线程通过参数arg来给子线程发送数据
2.子线程用pthread_exit()退出，主线程用pthread_join()来接受子线程的值
3.全局变量

代码说明：

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

/*
    单进程
*/

int val = 250; // 全局变量---数据段中 ok

// 子线程start_routine1
void *start_routine1(void *arg)
{
    printf("[%d][%s]\n", __LINE__, __FUNCTION__);
    int num = *(int *)arg;

    // 子线程退出一个自己的值"1" 模拟return 1的写法
    //"1"字符串常量--->.raodata----->数据段
    pthread_exit((void *)"1"); // char *类型

}

int main()
{
    /*
        主线程
    */

    // 创建一个子线程
    int num = 10;

    int ret = 0;
    pthread_t tid; // 不要定义成pthread_t *tid
    ret = pthread_create(&tid, NULL, start_routine1, (void *)&num);
    if (ret != 0)
    {
        perror("pthread_create fail");
        return -1;
    }

    //结合子线程
    void *retval = NULL; // 不要定义成void **retval
    //&retval的类型就是void **类型
    ret = pthread_join(tid, &retval); // retval指针是通过函数pthread_join给它空间
    if (ret != 0)
    {
        perror("pthread_join fail");
    }
    // 此处接收的是全变变量 int val=250
    printf("pthread_join success retval:%d\n",*(int*)retval); //如果retval没有空间的一定会段错误(段错误的原因就是访问空指针)


    return 0;
}

总结

没有总结…下篇继续…

IT新狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++多线程-多核编程
逍遥云恋
01-10 3062
多核编程并不是最近才兴起的新鲜事物。早在intel发布双核cpu之前，多核编程已经在业内存在了，只不过那时候是多处理器编程而已。为了实现多核编程，人们开发实现了几种多核编程的标准。open-mp就是其中的一种。对于open-mp还不太熟悉的朋友，可以参照维基百科的相关解释。 open-mp的格式非常简单，原理也不难。它的基本原理就是创建多个线程，操作系统把这几个线程分到几个核上面同时执行，从而可以...
操作系统上机-Linux多线程编程
05-18
操作系统上机-Linux多线程编程
Linux线程：概念、特点、线程间资源共享情况
坚持学习
04-30 1724
Linux线程概念 & 线程特点 & 线程共享与非共享资源
第三十篇，进程之间的通讯方式——内存共享，内存互斥关系——信号量，Linux下的最小资源单位——线程的详细讲解
weixin_44651073的博客
03-31 859
一、进程之间的通信方式 --- 共享内存。 1、共享内存也是属于IPC对象，所以在使用共享内存之前一定要申请key值与ID号。 2、共享内存作用机制以及使用范围。 作用范围：由于共享内存是IPC对象，属于系统的资源，所以在整个系统中都可以看到IPC对象，其作用范围就是linux下任意的两个进程。 机制：任意一个进程可以将数据发送到共享内存上，另外的进程就可以访问内存上的数据。 3、实现共享内存的步骤： 1）先申请key值 key = ftok(".",10); 2）根据申请到的key值去申请...
Linux线程
抚琴弹出情凋零的博客
04-17 2330
1.线程的概念 LWP：light weight process 轻量级的进程，本质任然是进程（在Linux环境下） 进程：独立地址空间，拥有PCB 线程：也有PCB，但没有独立的地址空间（共享） 区别：在于是否共享地址空间；独居（进程）， 合租（线程） Linux下：线程：最小的执行单位 进程：最小分配资源单位，可看成是只有一个线程的进程 一个进程内部可以有多个线程，默认情况下一个进程只有一个线程 内核实现都是通过clone实现的 线程也有自己的PCB 查看LWP号：ps -Lf pi
C#高级--多线程详解
热门推荐
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
golang并发编程-02多线程编程-01线程概述
运维玄德公
05-06 2836
文章目录1. 概念1.1 线程1.2 线程和进程1.3 线程的标识2. 线程控制2.1 线程间控制2.1.1 创建线程2.1.2 终止线程2.1.3 连接已终止的线程2.1.4分离线程2.2 线程自我控制2.2.1 终止2.1.2 分离3 线程状态4 线程的调度5 线程实现模型5.1 用户级线程模型5.2 内核级线程模型5.3 两级线程模型 1. 概念 1.1 线程 线程：可以被看作是在某个进程中的一个控制流。 主线程：一个进程的第一个线程会随着它的启动而被创建，该线程被称为主线程 1.2 线程和进程
java-多线程编程
weixin_53700016的博客
04-18 2228
1、基本概念 程序：是为了完成某特定任务，用某语言编写的一组指令的集合。 进程：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程中的一个实体，作为系统调度和分派的基本单位。 一个java程序的正常运行，至少需要三个线程。（main主线程、gc垃圾回收线程、议程处理线程） 并行：多个CPU同时执行多个任务。 并发：一个CPU采用时间片的方法同时执行多个任务 2、线程的状态 新建（New）：在程序中用构造方法创建一个线程对象后，新的线程对象便
Linux -- 多线程编程之 - 基础实现一
青椒*^_^*凤爪爪的博客
12-27 5178
为了进一步减少处理器的空转时间，支持多处理器以及减少上下文切换的开销，进程在烟花中出现了另一个概念 --- 线程，它是进程内独立的一条运行路线，是内核调度的最小单元，也被成为轻量级进程。线程具有高效性和可操作性，在嵌入式发开中运用的十分广泛。
libhv教程16--多线程/多进程服务端编程
HW的博客
09-18 7319
本篇介绍服务端编程的多线程/多进程模式以及使用libhv如何实现。 文章目录`one thread per connection`：每个连接一个线程`one loop per thread`：每个线程一个事件循环`multi-acceptor-processes`：多accept进程模式`multi-acceptor-threads`：多accept线程模式`one-acceptor-multi-workers`：一个accept线程+多worker线程last one thread per connect
Java并发编程-进程和线程调度基础
千月落
02-20 1万+
操作系统一般是按照一定策略，定期给每个活动的进程执行其内部程序的机会，并且每次只执行一小段时间，然后操作系统利用中断强行退出执行，将当前程序信息压栈，然后开始执行下一个进程的一小段程序。通过这样不断快速的循环切换，每个程序都获得执行，在用户看来，感觉到很多程序都在平行的执行。
Linux系统编程-线程
11-04
Linux系统编程-线程
Linux系统设计-Linux-系统编程
01-10
Linux系统是一个免费使用和自由传播的类Unix操作系统，基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统，Linux是许多企业...
Linux系统下的多线程编程入门.pdf
12-20
Linux系统下的多线程编程入门
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 358
unordered_map实现输出前k个高频元素
回溯之分割回文串
JINbigXIA的博客
06-04 201
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1231
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 458
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
c++ - 模板(二)
最新发布
2302_79539362的博客
06-05 824
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
00-linux系统编程常识-王保明
01-21
本书系统地介绍了Linux系统编程的概念、原理和方法，涵盖了进程管理、文件操作、内存管理、多线程编程、网络编程等多个方面，使读者能够全面掌握Linux系统编程的相关知识。 王保明在书中以通俗易懂的语言对Linux...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值