在操作系统中，线程的运行逻辑分析

最新推荐文章于 2025-01-16 23:44:38 发布
最新推荐文章于 2025-01-16 23:44:38 发布
阅读量792 收藏 15
点赞数 26
分类专栏： 操作系统 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/139468045
版权

在操作系统中，线程的运行逻辑框架代码通常涉及线程的创建、调度、执行和终止。以下是一个简单的逻辑框架代码示例，展示了如何在一个多线程环境中管理线程的生命周期。这个示例使用了POSIX线程库（pthread）来演示基本的线程操作。

示例代码

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

// 线程函数
void* threadFunction(void* arg) {
    int threadNum = *((int*)arg);
    printf("Thread %d: Starting\n", threadNum);

    // 模拟线程工作
    sleep(1);

    printf("Thread %d: Finishing\n", threadNum);
    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    int resultCode;

    // 创建线程
    for (int i = 0; i < NUM_THREADS; ++i) {
        threadArgs[i] = i;
        printf("Main: Creating thread %d\n", i);
        resultCode = pthread_create(&threads[i], NULL, threadFunction, &threadArgs[i]);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    // 等待所有线程完成
    for (int i = 0; i < NUM_THREADS; ++i) {
        resultCode = pthread_join(threads[i], NULL);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to join thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    printf("Main: All threads completed successfully\n");
    return 0;
}

代码解释

  1. 线程函数：

    void* threadFunction(void* arg) {
    int threadNum = *((int*)arg);
    printf("Thread %d: Starting\n", threadNum);

    // 模拟线程工作
    sleep(1);

    printf("Thread %d: Finishing\n", threadNum);
    return NULL;
}

    这是每个线程将要执行的函数。它接收一个void*类型的参数，这里我们将其转换为一个整数来表示线程的编号。线程函数简单地打印出线程的开始和结束信息，并模拟一些工作（通过sleep函数）。

  2. 主函数：

    int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    int resultCode;

    // 创建线程
    for (int i = 0; i < NUM_THREADS; ++i) {
        threadArgs[i] = i;
        printf("Main: Creating thread %d\n", i);
        resultCode = pthread_create(&threads[i], NULL, threadFunction, &threadArgs[i]);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    // 等待所有线程完成
    for (int i = 0; i < NUM_THREADS; ++i) {
        resultCode = pthread_join(threads[i], NULL);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to join thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    printf("Main: All threads completed successfully\n");
    return 0;
}

    • 线程创建：

      for (int i = 0; i < NUM_THREADS; ++i) {
    threadArgs[i] = i;
    printf("Main: Creating thread %d\n", i);
    resultCode = pthread_create(&threads[i], NULL, threadFunction, &threadArgs[i]);
    if (resultCode) {
        fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
        exit(EXIT_FAILURE);
    }
}

      使用pthread_create函数创建多个线程，每个线程执行threadFunction函数。线程的编号通过threadArgs数组传递给线程函数。

    • 等待线程完成：

      for (int i = 0; i < NUM_THREADS; ++i) {
    resultCode = pthread_join(threads[i], NULL);
    if (resultCode) {
        fprintf(stderr, "Error: Unable to join thread %d, %d\n", i, resultCode);
        exit(EXIT_FAILURE);
    }
}

      使用pthread_join函数等待所有线程完成。pthread_join函数会阻塞主线程，直到指定的线程终止。

    • 主线程结束：

      printf("Main: All threads completed successfully\n");
return 0;

      打印出所有线程完成的信息，并正常退出程序。

结语

这个示例展示了一个基本的多线程程序的逻辑框架，包括线程的创建、执行和终止。通过这种方式，可以在应用程序中实现并发执行，提高程序的性能和响应速度。希望这个示例对你理解线程的运行逻辑有所帮助。

好的，接下来我们可以进一步探讨一些高级的线程管理和同步机制，以便更好地理解和控制多线程程序的行为。

1. 线程同步

在多线程环境中，多个线程可能会访问共享资源，这可能导致竞争条件和数据不一致。为了避免这些问题，我们需要使用同步机制。常见的同步机制包括互斥锁（mutex）、读写锁（read-write lock）、条件变量（condition variable）和信号量（semaphore）。

互斥锁（Mutex）

互斥锁用于保护共享资源，确保同一时刻只有一个线程可以访问该资源。

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

pthread_mutex_t lock;
int sharedResource = 0;

void* threadFunction(void* arg) {
    pthread_mutex_lock(&lock);
    sharedResource++;
    printf("Thread %d: Shared Resource = %d\n", *((int*)arg), sharedResource);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    int resultCode;

    pthread_mutex_init(&lock, NULL);

    for (int i = 0; i < NUM_THREADS; ++i) {
        threadArgs[i] = i;
        resultCode = pthread_create(&threads[i], NULL, threadFunction, &threadArgs[i]);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    printf("Main: All threads completed successfully\n");
    return 0;
}
条件变量（Condition Variable）

条件变量用于线程间的通信，通常与互斥锁一起使用。它允许线程在某个条件满足时被唤醒。

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

pthread_mutex_t lock;
pthread_cond_t cond;
int ready = 0;

void* threadFunction(void* arg) {
    pthread_mutex_lock(&lock);
    while (!ready) {
        pthread_cond_wait(&cond, &lock);
    }
    printf("Thread %d: Proceeding\n", *((int*)arg));
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    int resultCode;

    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond, NULL);

    for (int i = 0; i < NUM_THREADS; ++i) {
        threadArgs[i] = i;
        resultCode = pthread_create(&threads[i], NULL, threadFunction, &threadArgs[i]);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
    }

    sleep(1); // 模拟一些工作
    pthread_mutex_lock(&lock);
    ready = 1;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&lock);

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    printf("Main: All threads completed successfully\n");
    return 0;
}

2. 线程池

线程池是一种预先创建一定数量的线程，并将任务分配给这些线程执行的机制。线程池可以减少线程创建和销毁的开销，提高系统性能。

简单的线程池实现
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM_THREADS 5
#define QUEUE_SIZE 10

typedef struct {
    void (*function)(void*);
    void* argument;
} Task;

typedef struct {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    pthread_t threads[NUM_THREADS];
    Task taskQueue[QUEUE_SIZE];
    int queueSize;
    int head;
    int tail;
    int count;
    int shutdown;
} ThreadPool;

void* threadPoolWorker(void* arg) {
    ThreadPool* pool = (ThreadPool*)arg;
    while (1) {
        pthread_mutex_lock(&pool->lock);
        while (pool->count == 0 && !pool->shutdown) {
            pthread_cond_wait(&pool->cond, &pool->lock);
        }
        if (pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            pthread_exit(NULL);
        }
        Task task = pool->taskQueue[pool->head];
        pool->head = (pool->head + 1) % QUEUE_SIZE;
        pool->count--;
        pthread_mutex_unlock(&pool->lock);
        task.function(task.argument);
    }
    return NULL;
}

void threadPoolInit(ThreadPool* pool) {
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->cond, NULL);
    pool->queueSize = QUEUE_SIZE;
    pool->head = 0;
    pool->tail = 0;
    pool->count = 0;
    pool->shutdown = 0;
    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_create(&pool->threads[i], NULL, threadPoolWorker, pool);
    }
}

void threadPoolAddTask(ThreadPool* pool, void (*function)(void*), void* argument) {
    pthread_mutex_lock(&pool->lock);
    pool->taskQueue[pool->tail].function = function;
    pool->taskQueue[pool->tail].argument = argument;
    pool->tail = (pool->tail + 1) % QUEUE_SIZE;
    pool->count++;
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->lock);
}

void threadPoolDestroy(ThreadPool* pool) {
    pthread_mutex_lock(&pool->lock);
    pool->shutdown = 1;
    pthread_cond_broadcast(&pool->cond);
    pthread_mutex_unlock(&pool->lock);
    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(pool->threads[i], NULL);
    }
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->cond);
}

void exampleTask(void* arg) {
    int num = *((int*)arg);
    printf("Thread %ld: Task %d is being processed\n", pthread_self(), num);
    sleep(1);
}

int main() {
    ThreadPool pool;
    threadPoolInit(&pool);

    int taskArgs[20];
    for (int i = 0; i < 20; ++i) {
        taskArgs[i] = i;
        threadPoolAddTask(&pool, exampleTask, &taskArgs[i]);
    }

    sleep(5); // 等待所有任务完成
    threadPoolDestroy(&pool);
    printf("Main: All tasks completed successfully\n");
    return 0;
}

3. 线程的优先级

在某些情况下，可能需要设置线程的优先级，以便某些重要的线程能够优先执行。POSIX线程库提供了设置线程优先级的功能。

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

void* threadFunction(void* arg) {
    int threadNum = *((int*)arg);
    printf("Thread %d: Starting\n", threadNum);
    sleep(1);
    printf("Thread %d: Finishing\n", threadNum);
    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];
    int threadArgs[NUM_THREADS];
    int resultCode;
    struct sched_param param;
    int policy = SCHED_FIFO;

    for (int i = 0; i < NUM_THREADS; ++i) {
        threadArgs[i] = i;
        pthread_attr_t attr;
        pthread_attr_init(&attr);
        pthread_attr_setschedpolicy(&attr, policy);
        param.sched_priority = sched_get_priority_max(policy) - i;
        pthread_attr_setschedparam(&attr, &param);
        pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
        resultCode = pthread_create(&threads[i], &attr, threadFunction, &threadArgs[i]);
        if (resultCode) {
            fprintf(stderr, "Error: Unable to create thread %d, %d\n", i, resultCode);
            exit(EXIT_FAILURE);
        }
        pthread_attr_destroy(&attr);
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    printf("Main: All threads completed successfully\n");
    return 0;
}

结语

通过以上示例，我们展示了多线程编程中的一些高级概念和技术，包括线程同步、线程池和线程优先级设置。这些技术可以帮助你更好地管理和优化多线程程序，提高程序的性能和可靠性。希望这些示例对你理解和应用多线程编程有所帮助。

多线程处理耗时的业务逻辑
lxlismy
10-31 2327
上传sftp大量数据,造成页面假死,用户体验不好使用多线程,页面显示成功,后台让他慢慢上传.有问题留言, //定义线程池 public static ExecutorService tmasCsggpool = Executors.newFixedThreadPool(1);//线程//创建线程,并发送sftp Map<Integer, Future> map = new
【操作系统】第六话·线程是进程的(宝ᴗ宝)嘛？
kikokingの比特宇宙
04-05 9741
从今天开始，我们将要开启一个新的系列【闪耀计划】，没错！这是今年上半年的一整个系列计划！本专题目的是通过百天刷题计划，通过题目和知识点串联的方式，完成对计算机操作系统的复习和巩固；同时还配有专门的笔记总结和文档教程哦！想要搞定，搞透计算机操作系统的同学，本专栏将会通过模块化的分类，刷够1000道题，为大家提供点对点的考点相关知识轰炸！值得注意的是，本专栏将会通过教程+课后习题的方式来进行巩固教学，课后习题的题量也是算入总题数的哦！
一文搞懂Java的多线程底层逻辑，再也不怕多线程了
我是香菜
09-19 2688
一文搞懂Java的多线程底层逻辑，再也不怕多线程了
2、线程池
weixin_44377171的博客
06-09 186
1、为什么需要线程池 在实际使用中，线程是很占用系统资源的，如果对线程管理不善，很容易导致系统问题。因此，在大多数bignfa
逻辑运算，&，&&, |, ||, ^, !
weixin_34377919的博客
03-17 5275
&：与 特点：判断时两边为true才为true，只要两边有一个为false则结果为false；true&true=true； false&true=false； true&false=false； false&false=false； &&: 短路与 特点：与&的结果是一样的，当左边为false后右边直接不进行运算，而...
高性能高稳定性分布式的游戏架构，游戏逻辑运行在Disruptor消费者线程中，其它线程都为辅助线程， 整体为多生产者.zip
12-17
本文将深入探讨一个使用Java开发的游戏项目，该项目采用了一种独特的方式，即游戏逻辑运行在Disruptor消费者线程中，其余线程作为辅助线程，构建了一个多生产者的分布式架构。这个设计模式旨在优化并发性能，提高...
操作系统之线程管理
有梦想的小新人的博客
03-29 1906
文章目录1.线程的基本特性1.1 线程引入的目的1.2 线程的属性1.3 线程的优缺点1.3.1 线程的优点1.3.2 线程的缺点2.线程的分类2.1 用户级线程(ULT)2.1.1 用户级线程定义2.1.2 用户级线程优点2.1.3 用户级线程缺点2.2 内核级线程(KST)2.2.1 内核级线程定义2.2.2 内核级线程优点2.2.3 内核级线程缺点2.3 轻量级线程(组合ULT、KST方式)2.3.1 多对一模型2.3.2 一对一模型2.3..3 多对多模型3.线程的上下文切换4.进程和线程的区别和联
操作系统（十二）线程的实现方式、多线程模型
qq_40608137的博客
03-04 1312
2.1.6 线程的实现方式、多线程模型 目录 2.1.6 线程的实现方式、多线程模型 2.1.6.1 线程的实现方式 2.1.6.2 多线程模型 2.1.6.1 线程的实现方式 线程已在许多系统中实现，但各系统的实现方式并不完全相同。在有的系统中，特别是一些数据库管理系统，所实现的是用户级线程；而另一些系统所实现的是内核级线程； 还有一些系统如 Solaris 操作系统，则同时实现...
【操作系统】多线程基础知识
qq_68993495的博客
10-08 3385
操作系统之多线程基础知识汇总，很想对你所帮助！喜欢就请三连支持吧，谢谢~
几种线程池异步处理逻辑的方法
福州零叶的博客
08-26 1810
Java提供的四种线程池的好处在于： a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。 b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。 c. 提供定时执行、定期执行、单线程、并发数控制等功能。 Java通过Executors提供四种线程池，分别为：newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲...
游戏中逻辑线程和逻辑线程的并行
bamei5868的博客
04-15 389
为什么要将游戏的渲染线程和逻辑线程分离？ 游戏中渲染是一个非常耗时的操作，特别是相对复杂的游戏，渲染通常会占据一帧中的大部分时间。而高品质的游戏都会要求FPS在60，所以一帧的时间仅仅16毫秒。 如果要在16毫秒内完成逻辑和渲染双重的任务，对于大型游戏来说，通常是艰难的，即使在极度优化的情况下，也可能只能满足性能较好的设备，在性能较差的设备上，几乎不可能在16毫秒内完成所有任务...
多线程处理业务逻辑
qq_39909392的博客
02-07 1315
多线程处理业务逻辑思路: 代码实例: final CountDownLatch latch = new CountDownLatch(2); ExecutorService threadPool = Executors.newFixedThreadPool(2); Callable c = new Callable() { public Integer call(
线程的一些逻辑性题目
a934275738的博客
11-29 240
线程这个东西只有实践才能出真知，工作上需求少，但是业余还是要偶尔锻炼下的，有意思的题目就放在这里，然后实现下 子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码。 用锁的概念实现才是正理 public class test { private static Object object = ne
关于目前架构的线程调度逻辑
qq_38418182的博客
06-02 198
关于目前架构的线程调度逻辑 1、线程优先级越大，优先级越高 RCLibThreadSched::RegisterTask(&userTask, 38); 40的优先级比38的高。 使用此逻辑其实是将各个函数加入链表中，按照优先级串行执行，并不是严格意义的并发。 相同优先级的线程函数安装添加顺序先后执行，而不是并发。 2、线程调度逻辑 int main(){ SRCI_SCHED_InitUserTask(&userTask); //初始化 userTask.loop_
关于网游服务器逻辑多线程处理的一些经验
ddddfbb的专栏
03-07 1752
<br />      众所周知，现在比较流行的网游服务端结构是逻辑单线程, 但是总会有一些其他原因促使你的架构不一定会按照最完美的情况来进行。下面就我上一个多线程逻辑的项目来说下一些要注意的事情和经验。<br />      按场景分线程应该是比较合理的一个方法，可以这么理解:N个场景运行在同一个线程之内。而人物又是运行在场景之内的，那么问题就出来了，当A线程操作B线程玩家的指针的时候，而B玩家突然下线 ，导致这个指针被释放，则导致程序崩溃。最简单的方法是在所有需要在所有有可能操作他人指针的时候进行加锁处
tomcat项目运行后报500
最新发布
m0_73232151的博客
01-16 277
错误，确保项目正常运行。同时，需要注意 Tomcat 版本和 Servlet API 版本的兼容性，以避免类似问题的再次发生。这里使用了 Jakarta Servlet API 5.0.0 版本，它与 Tomcat 10.1.19 相匹配。同样使用 Jakarta Servlet API 5.0.0 版本。通过上述步骤，你可以解决因 Servlet API 类缺失导致的。tomcat项目运行后，浏览器端显示500，这将更新项目的依赖并重新打包。
Spring Cloud 路由与过滤器
yuehua00的专栏
01-13 631
除了使用内置过滤器外，你还可以定义自己的过滤器。自定义过滤器需要实现`GatewayFilter`或`GlobalFilter`接口。示例：@Component@Override// 在这里添加自定义的过滤逻辑// 这里是响应后的逻辑}));在上述例子中，`CustomFilter`实现了`GatewayFilter`和`Ordered`接口，说明了如何在请求前和响应后执行自定义逻辑。
操作系统中的线程与进程概念解析
在操作系统中，线程的概念至关重要，因为它直接影响到系统的并发性和效率。线程允许在一个进程中同时执行多个不同的任务，提高了CPU的利用率。线程的调度由操作系统内核负责，根据预定的调度策略决定哪个线程应该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

你一身傲骨怎能输

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

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

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

打赏作者

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

抵扣说明：

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

余额充值