Linucx -- 线程（二）

最新推荐文章于 2022-08-26 14:11:29 发布
最新推荐文章于 2022-08-26 14:11:29 发布
阅读量239 收藏
点赞数
文章标签： c语言 数据结构 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuechanba/article/details/119845304
版权
本文详细介绍了线程同步的概念，通过代码示例展示了线程同步问题及解决方案。分析了由于资源共享、调度随机导致的数据混乱，并讲解了互斥量（mutex）机制在解决线程同步中的作用，包括动态和静态初始化互斥量。同时，讨论了条件变量在改善忙等法中的应用，以更高效地实现线程间的协作。最后，给出了使用条件变量改进顺序输出和筛质数算法的例子，展示了条件变量如何提高程序效率。
摘要由CSDN通过智能技术生成

线程同步的概念

在这里插入图片描述
在这里插入图片描述
代码举例1

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

void* thr1(void* arg)
{
    while(1)
    {
        printf("hello");//hello在缓冲区中，遇到\n才会输出出来
        sleep(rand()%3);//范围是0-2
        printf("world\n");
        sleep(rand()%3);
    }
}

void* thr2(void* arg)
{
    while(1)
    {
        printf("HELLO");
        sleep(rand()%3);//失去CPU
        printf("WORLD\n");
        sleep(rand()%3);
    }
}

int main()
{
    pthread_t tid[2];
    pthread_create(&tid[0],NULL,thr1,NULL);
    pthread_create(&tid[1],NULL,thr2,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);

    return 0;
}

程序运行结果如下：
在这里插入图片描述
造成这种数据混乱的原因是什么呢？
调度随机、线程间缺乏必要的同步机制

代码举例2

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

char buf[20];

void* thr1(void* arg)
{
    int i=0;
    for(;i<20;i++)
    {
        usleep(rand()%3);
        buf[i]='0';
    }
    return NULL;
}

void* thr2(void* arg)
{

    int i=0;
    for(;i<20;i++)
    {
        usleep(rand()%3);
        buf[i]='1';
    }
    return NULL;
}

int main()
{
    memset(buf,0x00,sizeof(buf));
    pthread_t tid[2];
    pthread_create(&tid[0],NULL,thr1,NULL);
    pthread_create(&tid[1],NULL,thr2,NULL);

    pthread_join(tid[0],NULL);
    pthread_join(tid[1],NULL);

    printf("buf is %s.\n",buf);

    return 0;
}

在这里插入图片描述
造成这种数据混乱的原因是什么呢？
资源共享、调度随机、线程间缺乏必要的同步机制
在这里插入图片描述
解决同步的问题：加锁（互斥量机制）。
在这里插入图片描述
因此，即使有了mutex，如果有线程不按规矩来访问数据，依然会造成数据混乱。

mutex 互斥量机制的相关函数

使用互斥量机制之前，需要进行初始化，有两种初始化方式：

1、动态初始化方式
在这里插入图片描述
2、静态初始化方式
在这里插入图片描述
动态初始化和静态初始化会放在不同的情况下使用。
比如你的互斥量就是凭空定义出来的变量时，使用静态初始化方式就够用了。
比如你的互斥量是位于某个结构体中的，你就必须使用动态初始化方式。
在这里插入图片描述
在这里插入图片描述
pthread_mutex_lock是死心眼，必须要加锁，当锁被别人占用时，就死等（阻塞等待）。
而pthread_mutex_trylock则是尝试加锁，如果加不上，就走。
在这里插入图片描述
在这里插入图片描述
程序结束且不再对互斥量操作了，要摧毁锁。

互斥量机制相关函数的使用

同一时间段只能有一个线程执行的那段代码称之为临界区

//全局变量--共享数据
char buf[20];

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

/*上锁的目的主要是为了操作共享数据*/
void* thr1(void* arg)
{
    //上锁
    pthread_mutex_lock(&mutex);
    /*进入临界区--不要一直占用临界区（比如延时）*/
    int i=0;
    for(;i<20;i++)
    {
        buf[i]='0';
    }
    //解锁
    pthread_mutex_unlock(&mutex);
    /*退出临界区*/
    
    return NULL;
}

通过下面这个例子来理解互斥锁锁住的是一段代码。

练习：有四个线程，这四个线程拼命的往终端上输出abcd.

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

#define THRNUM 4

void* thr_func(void *p)
{
    int c = 'a'+(int)p;
    while(1)
    {
        write(1,&c,1);
    }

    pthread_exit(NULL);
}

int main()
{
	pthread_t tid[THRNUM];
	
    int i,err;
    for(i=0;i<THRNUM;i++)
    {                           //传给线程执行函数的参数
        err = pthread_create(tid+i,NULL,thr_func,(void *)i);

        if(err)
        {
            fprintf(stderr,"pthread_create():%s\n",strerror(err));
            exit(1);
        }
    }

    alarm(3);

    for(i=0;i<THRNUM;i++)
    {
        pthread_join(tid[i],NULL);
    }

    exit(0);
}

程序执行结果如下：
在这里插入图片描述
我们从打印结果可以看出输出的序列中要么是单个字母序列，要么就是两个字母序列，就是没有三个字母序列或者四个字母序列的，那到底是什么原因呢？是因为，我们的虚拟机是双核的，只能模拟两个线程并发执行的情形，不能实现三个线程并发。

程序并没有像我们期待的那样输出abcd序列，那怎么解决这个问题呢？

定义互斥量，让打印 ‘a’ 字符的线程去解锁打印 ‘b’ 字符的线程，以此类推。
那这样就需要四个互斥量。

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

#define THRNUM 4

//定义四个互斥量
static pthread_mutex_t mut[THRNUM];

static int next(int n)
{
    if(n+1 == THRNUM)
    {
        return 0;
    }
    return n+1;
}

void* thr_func(void *p)
{
    int n =(int)p;//第n把锁
    int c = 'a'+ n;
    while(1)
    {
        //把自己给锁上
        pthread_mutex_lock(mut+n);
        write(1,&c,1);
        pthread_mutex_unlock(mut+next(n));
    }

    pthread_exit(NULL);
}

int main()
{
    pthread_t tid[THRNUM];

    int i,err;
    for(i=0;i<THRNUM;i++)
    {
        //创建四把锁
        pthread_mutex_init(mut+i,NULL);
        pthread_mutex_lock(mut+i);

        //创建了四个线程,i是传给线程执行函数的参数
        err = pthread_create(tid+i,NULL,thr_func,(void *)i);

        if(err)
        {
            fprintf(stderr,"pthread_create():%s\n",strerror(err));
            exit(1);
        }
    }
    //主线程执行到这里后，四个线程都被创建出来了，但都因为lock而被阻塞。

    //解开第一个锁
    pthread_mutex_unlock(mut+0);

    alarm(3);

    for(i=0;i<THRNUM;i++)
    {
        pthread_join(tid[i],NULL);
    }

    exit(0);
}

需要注意代码执行逻辑和顺序。尤其需要注意的是那个while循环体中执行流程。

程序中，当四个线程都被创建出来了，但都因为lock而被阻塞。当主线程执行了unlock后，第一个线程不再被阻塞，将自己再次给锁起来后，输出字符 a ，然后将下一个进程给解锁，需要注意，因为有while的存在，以此类推。

看下输出结果。在这里插入图片描述

线程池（任务池）

"池"可以想象成就是一个容器保存着各种我们需要的对象。

标准的进程池或线程池是将进程或线程所在的位置模拟成 “池” 的实现。
在这里插入图片描述
我们要实现的目标：

利用线程完成对30000000–30000200之间质数的查找。

我们这里要做的并不是一个标准的线程池，相当于是做一个任务池。
在这里插入图片描述
定义一个全局变量num，上游的main线程利用num将任务（这里是一个个数）进行发放。下游定义3个线程来抢任务，比如上游将30000000扔了下去，那么下游就开始抢。那就看谁抢的快了。抢的快的那个人将30000000拿走。上游再将30000001放进去，如果执行30000000那个完成的够快，则再一起抢，否则的话，剩下的两个线程再一起抢，从而最大限度的利用当前所有的资源。

我们再定义几个状态，
在这里插入图片描述
当num大于0时，表明是任务，而当num等于0时，则表明当前没有任务，任务为空。这个0由取走任务的那个线程来写（该线程取走这个（任务）值后，立刻将num写成0），当下游的两个线程一看num=0，就知道当前没有任务。也就不再抢了。当上游线程发现num=0时，就会把下一个任务给放进去。依此类推。

总有一个时刻，任务会发放完毕。当任务结束，规定num的值为-1，
由main线程将num的值写为-1。下游的线程一看num=-1，就知道任务发放完毕了，就准备退出，然后上游线程（主线程）等着给他们收尸。

注意下述程序中有可能出现的死锁

查询法典型特点：加锁查看，解锁等待

代码编写如下：

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

#define LEFT   30000000
#define RIGHT  30000200
#define THRNUM 4

int num=0;

//从名字上体现我做互斥量是为了保障对num的使用，是一种独占资源的形式在使用。
pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;

void* thr_prime(void *p)
{
    int i,j,mark;

    while(1)
    {
        pthread_mutex_lock(&mut_num);
        while(num == 0)//说明没有新的任务
        {
             //解锁等待
             pthread_mutex_unlock(&mut_num);
             sched_yield();//作用是出让调度器给别的线程，可以理解为非常非常短的sleep,且不会引起调度颠簸
             //在出让调度器的这段时间，如果主线程将num的值写为不为0的数，说明下发了任务或任务结束，且由于num不为0,也就将不再执行while循环.
             pthread_mutex_lock(&mut_num);
        }

        //退出循环体，即将结束线程
        if(num == -1)
        {
             //需要注意
             //如果不写这句话就会造成死锁
             //一个锁对应两种情况的解锁
             pthread_mutex_unlock(&mut_num);
            //临界区内的任何一个跳转语句一定要记得解锁之后再跳转
             break;
        }
        
		i = num;//领取任务
        num=0;
        pthread_mutex_unlock(&mut_num);
        //拿到num值之后，不是0和-1时才去执行下面代码。
        mark = 1;
        for(j=2;j<i/2;j++)
        {
            if(i%j == 0)
            {
                mark = 0;
                break;
            }
        }
        if(mark)
        {
            printf("[%d]%d is a primer.\n",(int)p,i);
        }
    }

    pthread_exit(NULL);
}

int main()
{
    int i,err;

    pthread_t tid[THRNUM];

    for(i = 0;i < THRNUM;i++)
    {
        err = pthread_create(&tid[i],NULL,thr_prime,(void* )i);
        if(err)
        {
            fprintf(stderr,"pthread_create():%s\n",strerror(err));
            exit(1);
        }
    }
    
	for(i = LEFT;i <= RIGHT;i++)
    {
        //下发任务
        pthread_mutex_lock(&mut_num);
        //不能冒昧的直接将num的值给i，需要先进行判断
        //不能是if来判断,而是应该循环判断
        while(num!=0)
        {
            //需要让别人有机会将num的值变成0,所以需要先解锁
            pthread_mutex_unlock(&mut_num);
            //直接解锁就立刻去加锁，很有可能这把锁还是被你抢走，
            //所以需要有个停顿，让进程有机会将num的值给写0.
            //那么可以使用sleep(1);吗？需要注意如果使用sleep的话，
            //可能会引起当前进程调度的颠簸，因为使用sleep后，当前进程
            //会由running态切换到可中断的睡眠状态，当sleep时间结束后，
            //这个进程又会被切换到running态，从而引起进程调度颠簸。
            //使用sched_yield();可以使进程平稳过渡。
            sched_yield();//作用是出让调度器给别的线程，可以理解为非常非常短的sleep,且不会引起调度颠簸
            //在出让调度器的这段时间，如果有线程将num的值写为0，说明有线程领取任务，且由于num=0,将不再执行while循环.

            //再马上加锁
            pthread_mutex_lock(&mut_num);
        }
        num = i;
        //当前下发任务完成
        pthread_mutex_unlock(&mut_num);
    }

    //所有任务下发完毕，main线程需要将num的值写为-1
    //但这里依然不能掉以轻心，首先，因为是要修改num的值，所以依然要加锁解锁
    //其次，当我们发放完最后一个任务时，也就是执行了num=i之后，接着执
    //行pthread_mutex_unlock(&mut_num);然后执行i++,此时,i的值不满足循环条件，从而跳出循环体
    //继而执行下面抢锁命令,因为它们属于同一线程，在抢锁有优势，所以有很大希望抢到锁，但是，
    //i=30000200(最后一个任务)还没有执行，就被你修改为-1了，这是不对的，所以这里也要不停的去判断。
    pthread_mutex_lock(&mut_num);
    //当num==0,说明最后一个任务也执行完毕了。此时，main线程才可以将num=-1
    while(num != 0)
    {
    	pthread_mutex_unlock(&mut_num);
         sched_yield();
         pthread_mutex_lock(&mut_num);
    }

    num = -1;
    pthread_mutex_unlock(&mut_num);


    for(i = 0;i< THRNUM;i++)
    {
        pthread_join(tid[i],NULL);
    }

    pthread_mutex_destroy(&mut_num);

    exit(0);
}

程序运行结果如下：
在这里插入图片描述
尽管使用 “池” 的方法来筛质数是非常可靠的一种方式，但是，从打印输出的结果来看，程序有些卡顿，且这段时间的CPU占用率非常的高，这是因为上下游都在等待，上游在不停的加锁查看，下游也在不停的加锁查看，都在等待num的值变化。也就是说大量资源被耗尽在不停的查询上，所以属于忙等法。

程序还有更好的方法是采用通知的方法，也就是当上游完成了，告诉下游，下游完成了，通知上游。采用通知的方法需要使用到一个机制 – 条件变量。

条件变量

条件变量中涉及到一个类型 pthread_cond_t

#include <pthread.h>

//与互斥量一样，条件变量也可以静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

//动态初始化
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
参数：cond是条件变量，cond_attr是属性，不需要设置时填NULL。

//条件变量的销毁
int pthread_cond_destroy(pthread_cond_t *cond);
参数：cond是条件变量

具体用法还涉及到
怎么样去发一个消息呢？

//把所有的等待都叫醒
int pthread_cond_broadcast(pthread_cond_t *cond);
参数：cond是条件变量

//叫醒任意一个等待
int pthread_cond_signal(pthread_cond_t *cond);
参数：cond是条件变量

需要注意：这里的signal和信号那个signal无关。

还有

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
参数：cond是条件变量，mutex是互斥量

pthread_cond_wait 是死心眼，一直等待，直到有人来打断我为止。

pthread_cond_timedwait 是规定的时间内等不到就直接结束。其中参数abstime是超时设置，表示在我等待的abstime时间内，还没有发生我等待的行为的话，就结束。

1、使用条件变量来修改令牌桶的代码（见令牌桶章节）

2、使用条件变量来修改筛质数的代码

前面我们使用互斥量实现的本质是查询法的筛质数，上游和下游都不停的抢num，看状态。

上游抢num，期待它是0，下游抢num，期待它不是0。

现在，我们把它变成通知法，应该是这样一个逻辑。
比如当前下游一直处于一个等待状态。上游把任务放到num之后，给下游正在wait的几个线程发一个通知，使用signal就可以，因为下游几个线程的目的是一样的。叫醒任何一个，叫他取任务都可以。

如果现在下游都在忙，我的signal没有打断任何一个wait，那应该怎么办？
答：最先完成任务的程序执行到wait这个位置，再做处理。

当下游的某个线程将num取走之后，会使用pthread_cond_broadcast函数给main线程和其他正在等待的线程都发一个通知。
main线程接到通知后，知道任务被取走了，要再发任务或结束任务。
其他正在等待的线程收到通知,知道任务被别人取走了,继续等待.

具体看代码如何实现。

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

#define LEFT   30000000
#define RIGHT  30000200
#define THRNUM 4

int num=0;

//从名字上体现我做互斥量是为了保障对num的使用，是一种独占资源的形式在使用。
pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_num = PTHREAD_COND_INITIALIZER;

void* thr_prime(void *p)
{
    int i,j,mark;

    while(1)
    {
        pthread_mutex_lock(&mut_num);
        while(num == 0)//说明没有新的任务
        {
             pthread_cond_wait(&cond_num, &mut_num);
        }

        //退出循环体，即将结束线程
        if(num == -1)
        {
             //需要注意
             //如果不写这句话就会造成死锁
             //一个锁对应两种情况的解锁
             pthread_mutex_unlock(&mut_num);
            //临界区内的任何一个跳转语句一定要记得解锁之后再跳转
             break;
        }

        i = num;//领取任务
        num=0;
        //给所有线程发通知,主线程收到通知,知道要再发任务或结束任务了,
        //其他正在等待的线程收到通知,知道任务被别人取走了,继续等待.
        //解锁之前发通知可以先让主线程准备好抢锁.让其他线程继续保持等待状态.
		//所以应该使用pthread_cond_broadcast
        pthread_cond_broadcast(&cond_num);
        pthread_mutex_unlock(&mut_num);
        //拿到num值之后，不是0和-1时才去执行下面代码。
        mark = 1;
        for(j=2;j<i/2;j++)
        {
            if(i%j == 0)
            {
                mark = 0;
                break;
            }
        }
        if(mark)
        {
            printf("[%d]%d is a primer.\n",(int)p,i);
        }
    }

    pthread_exit(NULL);
}

int main()
{
    int i,err;

    pthread_t tid[THRNUM];

    for(i = 0;i < THRNUM;i++)
    {
        err = pthread_create(&tid[i],NULL,thr_prime,(void* )i);
        if(err)
        {
            fprintf(stderr,"pthread_create():%s\n",strerror(err));
            exit(1);
        }
    }

    for(i = LEFT;i <= RIGHT;i++)
    {
        //下发任务
        pthread_mutex_lock(&mut_num);
        //不能冒昧的直接将num的值给i，需要先进行判断
        //不能是if来判断,而是应该循环判断
        while(num!=0)
        {
            pthread_cond_wait(&cond_num, &mut_num);
        }
        num = i;
        //给任意一个线程发就行
        pthread_cond_signal(&cond_num);

        //当前下发任务完成
        pthread_mutex_unlock(&mut_num);
    }

    pthread_mutex_lock(&mut_num);
    //当num==0,说明最后一个任务也执行完毕了。此时，main线程才可以将num=-1
    while(num != 0)
    {
        pthread_cond_wait(&cond_num, &mut_num);
    }

    num = -1;
    //给所有线程发,任务结束,让他们都准备退出吧.
    pthread_cond_broadcast(&cond_num);
    pthread_mutex_unlock(&mut_num);


    for(i = 0;i< THRNUM;i++)
    {
        pthread_join(tid[i],NULL);
    }

    pthread_mutex_destroy(&mut_num);
    pthread_cond_destroy(&cond_num);

    exit(0);
}

3、使用条件变量来修改顺序输出abcd的代码

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

#define THRNUM 4

static int num = 0;
//定义互斥量
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
//定义条件变量
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 
static int next(int n)
{
    if(n+1 == THRNUM)
    {
        return 0;
    }
    return n+1;
}

void* thr_func(void *p)
{
    int n =(int)p;
    int c = 'a'+ n;
    while(1)
    {
        pthread_mutex_lock(&mut);
        //当num的值不等于n时就等待
        while(num != n)
        {
            pthread_cond_wait(&cond, &mut);
        }

        write(1,&c,1);
        //打印完之后,我要让num的值变成num的下一个人的编号
        num = next(num);
        //然后通知下一个人,怎么通知呢？
        //实际上a在打印的时候,bcd都在等待,直接用broadcast叫醒所有
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mut);
	 }
    pthread_exit(NULL);
}

int main()
{
    pthread_t tid[THRNUM];

    int i,err;
    for(i=0;i<THRNUM;i++)
    {
        //创建了四个线程,i是传给线程执行函数的参数
        err = pthread_create(tid+i,NULL,thr_func,(void *)i);

        if(err)
        {
            fprintf(stderr,"pthread_create():%s\n",strerror(err));
            exit(1);
        }
    }
    //主线程执行到这里后，四个线程都被创建出来了.

    alarm(3);

    for(i=0;i<THRNUM;i++)
    {
        pthread_join(tid[i],NULL);
    }

    pthread_mutex_destroy(&mut);
    pthread_cond_destroy(&cond);

    exit(0);
}
xuechanba
关注
linux线程（面试会考）
weixin_44372427的博客
09-11 289
Linux线程介绍 进程与线程： 典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。 进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。 线程是操作系统能够进行运算调度的最小单位。它被包含在
多线程计算质数
陆星材的博客
05-27 1211
多线程计算质数： #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <pthread.h> #include <semaphore.h> #define LEFT 30000000 #define RIGHT 30001000 #define THRNUM 4 int value = 0;
linux c开多线程算质数,C语言判断素数（质数）
weixin_36472718的博客
05-11 368
这是一个C语言 while 循环的示例：判断一个整数 n(n>1)是否为素数(也成质数)。问题分析输入：一个整数n(n>1)。输出：Yes or No。如果一个整数 n(n>1)不能被 1 或 n 以外的正整数整除，那么 n 就是素数。因此，只要把 2 至 n-1 之间的每一个数字，分别作为除数，与 n 做除法，只要出现一次整除，就说明 n 不是素数；而一直没有出现整除现象，则说...
Linux操作系统简介
m0_67401382的博客
04-20 2万+
文章目录 Linux发行版简介 学习Linux的必备硬件知识 关键硬件器件——CPU 关键硬件器件——存储 关键硬件器件——内存 其他一些查看硬件信息的命令 Linux开机过程（以Ubuntu16.04为例） 阶段1：BIOS 阶段2：boot Loader 阶段3：kernel 阶段4：systemd 阶段5：应用软件 Linux常用命令 基本命令 文件管理 文本操作 磁盘管理 系统管理 网络通信 压缩解压 查询硬件信息的命令 多命令协作 git操作命令 Refere
Linux系统的多线程编程
风翼随心的博客
08-12 408
多线程 线程概念 线程可以看做是一个正在运行的函数，一个进程中至少有一个函数运行，那么也就是说一个进程至少有一个线程。在函数中创建出来的线程，彼此之间是兄弟关系。posix线程是一套线程标准，而不是一套实现。 线程的标识 pthread_t数据类型的线程标识符tid。在终端使用ps axm命令查看线程信息。 pthread_equal(tid1,tid2)：比较两个线程标识，相...
linux-进程和线程
最新发布
07-26
在Linux系统中，进程和线程是两种不同的执行单元，它们是系统管理和调度程序执行的基础。理解它们的概念、特性和操作方法对于进行高效且可靠的C编程至关重要。 1. **程序进程概念** - **概述**：一个进程可以看作...
Unix-Linux-Windows-OpenMP多线程编程.docx
10-12
Unix-Linux-Windows-OpenMP 多线程编程知识点总结 POSIX 的基本知识 POSIX（Portable Operating System Interface）是一种可移植操作系统接口标准，旨在提供源代码级的软件可移植性。POSIX 标准定义了操作系统应该...
Unix-Linux-Windows-OpenMP多线程编程.pdf
10-12
Unix-Linux-Windows-OpenMP 多线程编程 本文档主要介绍 Unix/Linux 多线程编程接口及编程技术，重点讲解 POSIX 的一些基本知识。POSIX 是可移植操作系统接口（Portable Operating System Interface）的首字母缩写，...
Node.js（node-v16.15.1-linux-x64.tar.xz）
06-08
Node.js 应用程序运行单线程，尽管 Node.js 使用多个线程来处理文件和网络事件。由于 Node.js 的异步特性，它通常用于实时应用程序。 Node.js 内部使用 Google V8 JavaScript 引擎来执行代码；大部分基本模块都是用...
jdk-8u181-linux-x64.tar.gz
07-20
- **Lambda表达式**：提供简洁的匿名函数，简化多线程编程和集合处理。 - **Stream API**：为集合操作提供了一种声明式编程风格，使得数据处理更加高效和易读。 - **Date和Time API**：全新的`java.time`包，替代了...
Linux--线程实例
03-21
3.21学习多线程编程-线程的使用 线程是进程中的一个独立的控制流，由环境和一系列要执行的指令组成。 线程的优点：占用资源少，通讯方便，可以提高应用程序响应，改善程序结构。
JDBC连接MySQL数据库
热门推荐
09-22 7万+
JDBC（Java Data Base Connectivity,java数据库连接）连接mysql数据库。
Linux -- 线程（一）
xuechanba的博客
08-21 449
线程概念 轻量级的进程（light weight process – LWP），一个进程内部可以有多个线程。默认情况下，一个进程只有一个线程。 进程和线程的简要关系图。 可以打一个比较形象的比喻。 上面提到，多个线程会共用一个进程的空间。 下图为一个进程的空间。 除了栈（stack）之外，其他空间都是共用的。 因为线程实际上是有自己的执行目的（逻辑）的。目的非常明确，比如刷碗就是刷碗的，打酱油就是带酱油的。等到后面会发现，实际上，线程执行的就是一个函数。函数是在栈上的，所以栈是不被共享的。 由此，可
安装centos安装mysql
gjk576238725的专栏
03-05 508
有好的安装方法请给个建议
linux的一些基本操作命令
飞扬晴雪
05-21 133
linucx的一些基本操作命令1.环境准备2.基本命令2.1.安装和卸载程序2.2.查询磁盘内存2.3.设置连接2.5.文件编辑和读取 1.环境准备 linucx版本： centos 7 2.基本命令 2.1.安装和卸载程序 示例:安装和卸载JDK 安装JDK [root@VM-0-14-centos /]# cd /home/yangzhenwei [root@VM-0-14-centos yangzhenwei]# ls apache-tomcat-9.0.45.tar.gz jdk-8u211-
Linux学习总结
唐滚滚的博客
10-29 4万+
Linux学习目标： Linux操作系统介绍与安装。 Linux常用命令。 Linux常用软件安装。 Linux网络。 防火墙。  Shell编程等。 ******************************************************************************LinuxOS介绍与安装***************************
条件变量基础
YoYuanZhizheng的博客
03-08 215
通常，条件变量和互斥锁搭配使用。 条件变量是用来弥补互斥锁的不足的。在我们使用互斥锁的时候，往往是为了等待某个线程修改完数据之类的条件满足后，释放互斥锁。这个过程中，其他线程会尝试竞争锁，竞争失败后才会进入阻塞队列，这个过程还是会消耗CPU的资源。 而使用条件变量以后，当条件满足的时候，会发送信号去唤醒等待这个条件的线程，去加锁，再判断条件是否满足。 至于为什么要再判断条件，这个一会再提。 总之，使用条件变量以后，线程就不需要主动去竞争锁，而是等待着被唤醒，这样可以提高CPU是利用率。 1.初始化条件变量
多线程互斥锁 pthread_mutex 的使用及初始化问题
咸鱼弟的博客
08-26 1万+
互斥锁 pthread_mutex 的使用及注意事项
golang的调度器原理
qq_30505673的博客
12-20 526
go语言的作者实现的C的协程库 libtask 源码分析，以理解协程的原理 任务调度概念任务与任务控制块（TCB） linux中称为进程控制块（PCB），即包含任务相关的数据结构，包含任务执行过程中的所有信息。 任务的名字 task name 任务的ID task id 任务的状态 task status 任务的优先级 task priority 任务的上下文（寄存器、堆栈指针、程序计数器(PC)...
Linux查看用户-j多少线程
06-09
在Linux系统中，可以使用 `ps` 命令来查看当前进程信息，其中 `-u` 选项可以用来限制只显示某个用户的进程信息。要查看某个用户的线程数量，可以将 `ps` 命令的输出传递给 `wc` 命令来计算行数。 以下是查看某个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuechanba

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值