C多线程编程- 近似求解π

已于 2023-10-15 16:51:57 修改
阅读量483 收藏 1
点赞数
分类专栏： 工程化C 文章标签： c语言
于 2023-10-15 16:00:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43844521/article/details/133843309
版权

本程序使用蒙特卡洛方法估算圆周率（π）。它首先创建了指定数量的线程，每个线程生成一个随机点并检查该点是否在单位圆内。基于这些线程的结果，程序计算在单位圆内的点的比例，并乘以4来估算π的值。为了对比，程序还直接在主线程中（没有并发）进行了相同的π估算过程（由于每次都是生成随机数，所以这个基准也没啥意义hh~）。最后，程序打印出两种方法得到的π值。

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

struct arg_t {
    float x;
    float y;
};

void *start(void *arg) {
    struct arg_t *ll = (struct arg_t *)arg;
    float x1 = ll->x;
    float y1 = ll->y;
    long M = 0;
    if (x1*x1 + y1*y1 <= 1.0) {
        M ++;
    }
    pthread_exit((void *)M);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Please provide a number as an argument.\n");
        exit(1);
    }
    long N1 = atol(argv[1]);
    // printf("%ld\n", N1);
    pthread_t tids[N1];

    // pai(concurrency)
    for (long i = 0; i < N1; ++ i) {
        struct arg_t *arg = malloc(sizeof(struct arg_t));
        int x = rand();
        int y = rand();
        arg->x = 1.0*x / RAND_MAX;
        arg->y = 1.0*y / RAND_MAX;
        pthread_create(&tids[i], 0, start, arg);
    }

    void *res = 0;
    long M = 0;
    for (long i = 0; i < N1; ++ i) {
        pthread_join(tids[i], &res);
        M += (long)res;
    }
    printf("pai = %f\n", 4.0*M/N1);  // concurrency

    // pai(oracle)
    M = 0;
    for (long i = 0; i < N1; ++ i) {
        int x = rand();
        int y = rand();
        float x1 = 1.0*x / RAND_MAX;
        float y1 = 1.0*y / RAND_MAX;
        if (x1*x1 + y1*y1 <= 1.0) {
            M ++;
        }
    }
    printf("pai = %f\n", 4.0*M/N1);  // oracle
    pthread_exit(0);
}

测试一下上述程序：

majn@tiger:~$ ./pai 10000
pai = 3.171200
pai = 3.142000
majn@tiger:~$ ./pai 100000
Segmentation fault (core dumped)

分析Segmentation fault的原因：

在上面的程序中，为每个线程都动态分配了 arg_t 结构的内存，但在线程执行完毕后，这些内存并没有被释放。虽然这不是立即的问题，但长期这样会导致内存泄露。应该在线程函数中或 pthread_join 之后释放这些内存。

改进方案：

一种方法是在线程函数 start 的结尾释放它（插个眼hh~）。但由于在主函数中可能还需要访问这些结构，更安全的方法是在 pthread_join 之后释放这些动态分配的内存。

修改上述代码：

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

struct arg_t {
    float x;
    float y;
};

void *start(void *arg) {
    struct arg_t *ll = (struct arg_t *)arg;
    float x1 = ll->x;
    float y1 = ll->y;
    long M = 0;
    if (x1*x1 + y1*y1 <= 1.0) {
        M ++;
    }
    pthread_exit((void *)M);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Please provide a number as an argument.\n");
        exit(1);
    }
    long N1 = atol(argv[1]);

    struct arg_t *args[N1];
    // printf("%ld\n", N1);
    pthread_t tids[N1];

    // pai(concurrency)
    for (long i = 0; i < N1; ++ i) {
        args[i] = malloc(sizeof(*args[i]));
        // struct arg_t *arg = malloc(sizeof(*arg));
        int x = rand();
        int y = rand();
        args[i]->x = 1.0*x / RAND_MAX;
        args[i]->y = 1.0*y / RAND_MAX;
        pthread_create(&tids[i], 0, start, args[i]);
    }

    void *res = 0;
    long M = 0;
    for (long i = 0; i < N1; ++ i) {
        pthread_join(tids[i], &res);
        M += (long)res;
        free(args[i]);
    }
    printf("pai = %f\n", 4.0*M/N1);  // concurrency

    // pai(oracle)
    M = 0;
    for (long i = 0; i < N1; ++ i) {
        int x = rand();
        int y = rand();
        float x1 = 1.0*x / RAND_MAX;
        float y1 = 1.0*y / RAND_MAX;
        if (x1*x1 + y1*y1 <= 1.0) {
            M ++;
        }
    }
    printf("pai = %f\n", 4.0*M/N1);  // oracle
    pthread_exit(0);
}

这样，每次线程执行完毕并被主线程收回后，对应的动态分配的内存都会被释放。

测试一下修改后的程序：

majn@tiger:~$ ./pai 100000
pai = 3.721760
pai = 3.137640
majn@tiger:~$ ./pai 1000000
Segmentation fault (core dumped)

好好好，这样玩儿是吧。

分析Segmentation fault的原因：

仔细观察上面的程序，我使用了一个固定大小的线程数组：pthread_t tids[N1];。对于大的 N1 值，这可能会导致栈溢出。在大多数系统上，默认的栈大小可能不足以容纳大量的 pthread_t 变量。

改进方案：

考虑动态分配线程ID数组的空间。

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

struct arg_t {
    float x;
    float y;
};

void *start(void *arg) {
    struct arg_t *ll = (struct arg_t *)arg;
    float x1 = ll->x;
    float y1 = ll->y;
    long M = 0;
    if (x1*x1 + y1*y1 <= 1.0) {
        M ++;
    }
    pthread_exit((void *)M);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Please provide a number as an argument.\n");
        exit(1);
    }
    long N1 = atol(argv[1]);

    struct arg_t *args[N1];
    // printf("%ld\n", N1);
    pthread_t *tids = malloc(N1 * sizeof(pthread_t));

    // pai(concurrency)
    for (long i = 0; i < N1; ++ i) {
        args[i] = malloc(sizeof(*args[i]));
        // struct arg_t *arg = malloc(sizeof(*arg));
        int x = rand();
        int y = rand();
        args[i]->x = 1.0*x / RAND_MAX;
        args[i]->y = 1.0*y / RAND_MAX;
        pthread_create(&tids[i], 0, start, args[i]);
    }

    void *res = 0;
    long M = 0;
    for (long i = 0; i < N1; ++ i) {
        pthread_join(tids[i], &res);
        M += (long)res;
        free(args[i]);
    }
    printf("pai = %f\n", 4.0*M/N1);  // concurrency

    // pai(oracle)
    M = 0;
    for (long i = 0; i < N1; ++ i) {
        int x = rand();
        int y = rand();
        float x1 = 1.0*x / RAND_MAX;
        float y1 = 1.0*y / RAND_MAX;
        if (x1*x1 + y1*y1 <= 1.0) {
            M ++;
        }
    }
    printf("pai = %f\n", 4.0*M/N1);  // oracle
    pthread_exit(0);
}

majn@tiger:~$ ./pai 1000000
pai = 3.972176
pai = 3.142136
majn@tiger:~$ ./pai 10000000
Segmentation fault (core dumped)

？？？不玩儿了！！！ 到此为止，我们把输入数据的规模N1从一开始最大接受10000扩大到现在最大接受1000000。

彩蛋： 要不然把为每个线程都动态分配的 arg_t 结构在线程函数 start 的结尾释放试一试？

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

struct arg_t {
    float x;
    float y;
};

void *start(void *arg) {
    struct arg_t *ll = (struct arg_t *)arg;
    float x1 = ll->x;
    float y1 = ll->y;
    long M = 0;
    if (x1*x1 + y1*y1 <= 1.0) {
        M ++;
    }
    free(arg);
    pthread_exit((void *)M);
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Please provide a number as an argument.\n");
        exit(1);
    }
    long N1 = atol(argv[1]);
    // printf("%ld\n", N1);
    // pthread_t tids[N1];
    pthread_t *tids = malloc(N1 * sizeof(pthread_t));

    // pi(concurrency)
    for (long i = 0; i < N1; ++ i) {
        struct arg_t *arg = malloc(sizeof(struct arg_t));
        int x = rand();
        int y = rand();
        arg->x = 1.0*x / RAND_MAX;
        arg->y = 1.0*y / RAND_MAX;
        pthread_create(&tids[i], 0, start, arg);
    }

    void *res;
    long M = 0;
    for (long i = 0; i < N1; ++ i) {
        pthread_join(tids[i], &res);
        M += (long)res;
    }
    printf("pai = %f\n", 4.0*M/N1);  // concurrency

    // pi(oracle)
    M = 0;
    for (long i = 0; i < N1; ++ i) {
        int x = rand();
        int y = rand();
        float x1 = 1.0*x / RAND_MAX;
        float y1 = 1.0*y / RAND_MAX;
        if (x1*x1 + y1*y1 <= 1.0) {
            M ++;
        }
    }
    printf("pai = %f\n", 4.0*M/N1);  // oracle
    pthread_exit(0);
}

majn@tiger:~$ ./pai_init 10000000
pai = 3.997218
pai = 3.141381
majn@tiger:~$ ./pai_init 100000000
pai = 3.999722
pai = 3.141420
majn@tiger:~$ ./pai_init 1000000000
^C   // 时间太长了，不想等了

Amazing！！！怎么这么神奇？

注： 蒙特卡洛方法（Monte Carlo method）是一种通过随机抽样来获得数值解的统计方法。这个方法得名于摩纳哥的蒙特卡洛赌场，因为它大量使用随机性和概率。蒙特卡洛方法在物理学、工程学、经济学和许多其他领域都有广泛的应用。

关键概念和特点：

  1. 随机抽样：这是蒙特卡洛方法的核心。为了得到一个问题的数值解，这个方法使用随机数或更通常地说，使用伪随机数。

  2. 统计结果：通过对大量的随机样本进行统计分析，得到的是一个近似解，而不是确切的解。

  3. 精度与样本数量：通常，随着样本数量的增加，估算的精度也会提高。但是，为了使误差减少到原来的一半，样本数通常需要增加四倍。

  4. 应用：蒙特卡洛方法在多种应用中都非常有用，尤其是在问题的解析解很难得到或者不存在时。例如，它被用于估算复杂积分、求解难以解析的统计物理问题、进行金融市场模拟等。

  5. 示例 - 估算π：一个经典的应用是使用蒙特卡洛方法估算π的值。方法是这样的：随机投掷点到单位正方形内，统计落在单位圆内的点的数量。落在圆内的点数与总点数的比例，乘以4，就给出了π的近似值。

简而言之，蒙特卡洛方法是一种利用随机性来求解问题的技术，通过对大量样本的统计分析来获得结果。

青衫客36
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程编程-使用同步对象编程
03-02
1、互斥锁（mutex）2、条件变量(conditionvariable)3、多读单写锁(multi-read,single-writelock)4、信号量(semophore)5、进程间同步(processsynchronization)6、同步原语的比较(compareprimitive)同步对象是内存中的变量，你可以象访问一般的数据那样来访问它。不同进程内的线程可以通过共享内存中的同步变量来同步，即使这些线程互不可见。同步变量可以放置在文件当中，可以比创建它的进程拥有更长的生命。·互斥锁·状态变量·读写锁·信号灯(信号量)·在两个或更多个进程内的线程可以合用一个同步变量。注意，同步变量应
C++ 多线程求PI
11-15
C++ 多线程求PI，里面有word文档 写的是思路
多线程设计实例——Monte Carlo法估算圆周率
weixin_46459918的博客
11-27 850
原理：作一个22正方形的内切圆，其圆心假设为(0,0)（如下图所示）且半径为1，生成一系列随机点(x,y)且这些点必须在正方形内，在所产生的所有随机点中，有一些点会出现在圆内，然后通过以下公式估算圆周率π的值： π = 4(圆内点总数)/(点的总数) 主要使用的是pthread.h头文件下的各类函数： int pthread_join(pthread_t thread, void **retval); int pthread_create(pthread_t *restrict tidp, const
操作系统原理：C语言 多线程加锁 验证蒙特·卡罗（Monte Carlo）方法求π值
SongXJ的博客
05-08 2011
蒙特·卡罗方法 蒙特·卡罗方法（Monte Carlo method），也称统计模拟方法，是一类随机方法的统称。这类方法的特点是，可以在随机采样上计算得到近似结果，随着采样的增多，得到的结果是正确结果的概率逐渐加大。 在本实验中通过在正方形区域中生成随机点，记录随机点在圆形区域中的个数计算 π\piπ 值。 π=4×(number  of  points  in  circle)/(total  ...
通过多线程计算PI的值
Y734493585的博客
07-28 5800
通过多线程计算PI的值 1.PI公式: PI=4*(1-1/3+1/5-1/7+…1/(n*2-1)) 2.多线程计算思路： 通过将PI的计算分为n个部分，分配到n个线程上进行计算，再将最后的结果进行求和。 3.计算步骤及原理： 设将PI的计算分为n个线程，共计算公式的前m次。 将一加一减固定为一个基本单位。即： （1-1/3）+（1/5-1/7）+…+(1/(2n-3)+1/(n*2-1)),...
【操作系统实验】多线程结合蒙特卡罗法计算圆周率
GeekKid的博客
07-30 517
在一个正方形内随机生成若干个点，生成的点落在其内接圆内的概率即可被估计为为的值。如果我需要进行多次实验，以找出一个合理的值，就需要调用多次这个函数。随着参数的变大以及调用次数的增加，消耗时间会逐渐增加。利用多线程，创建多个线程来执行计算，即可提升cpu时间利用率，从而提升计算效率。
多线程编程计算 π 的值
极客园地
12-17 1400
一、实验内容 使用 For 循环制导语句计算π 的值 二、运行结果 1、代码实现： #include <stdio.h> #include <omp.h> #include <cmath> #include <iostream> #include <stdlib.h> #include <time.h> #include "PrecisionNum.cpp" #include "stdint.h" void calculatePi3
多线程求π
VON
03-20 1839
之前说到过 python 的多线程求 π 问题，但当时并没有贴出代码来。因为确实是之前自己写的那个程序最后结果一直不对，明明逻辑语句都没问题了。 但恰恰是我没有注意到一点，多线程的同步问题。那个求最后总数 N 的值，如果没有进行同步锁的话，那么实际情况将会导致 N 的数量变少。就是因为一个线程未完成另一个线程突然的完成或者一起完成，我是这样认为的，总之一定会导致表面上的 N 大于实际未同步相加的
c语言多进程多线程编程
07-21
c语言多进程多线程编程
蒙特卡洛方法计算圆周率
李祖平大人的博客
02-24 1797
C语言实现蒙特卡洛方法计算圆周率
多线程 pi计算
05-21
使用随机数来计算pi值，使用多线程
多线程计算pi（精确到多位）
04-09
多线程计算pi（精确到多位），在linux操作系统下。
pthread多线程计算pi
06-16
读入第一个参数为线程数，第二个参数为N，积分法计算pi，C+pthread实现，附结果比较表
多线程计算pi，并比较性能
03-24
这个程序是在并行计算课上写的，利用posix多线程计算pi，运行环境是linux，编程语言：ANTI C。
多线程计算pi值
05-06
多线程计算pi值，运行与编译在linux系统下。
蒙特卡洛法计算圆周率近似值(C语言)
qq_49597570的博客
01-26 4152
C语言随机法计算圆周率近似值 由于使用随机法，因此每次结果都是不同的。原理就是随机生成数字并通过计算位于圆（XX+YY<1）内的概率估算。其中宏的参数(ALL和RAND_MAX)对于精确度非常关键。 #include<time.h> #include<stdio.h> #include<stdlib.h> #define ALL 100000 int main () { srand(time(0)); double X[ALL],Y[ALL]; int i
在Linux下用多线程估计π的值
最新发布
m0_64082403的博客
11-26 78
在Linux下用多线程估计π的值
多线程初体验——使用2个线程根据莱布尼兹级数计算PI、多线程排序
Alkali!的博客
04-24 561
2022.04.24 job7/pi1.c: 使用2个线程根据莱布尼兹级数计算PI 要求 莱布尼兹级数公式: 1 - 1/3 + 1/5 - 1/7 + 1/9 - … = PI/4 主线程创建1个辅助线程 主线程计算级数的前半部分 辅助线程计算级数的后半部分 主线程等待辅助线程运行結束后,将前半部分和后半部分相加 代码 #include<stdio.h> #include<pthread.h> #define NUMBER 1000000 double worker_res
linux多线程计算pi代码,多线程计算PI碰到的问题
weixin_31977649的博客
05-06 336
例子如下，用于计算PI的值。gIterations是计算PI的迭代次数，gThreadCount是线程的个数。方法是这样子的，把PI分成gThreadCount个段，分别让一个线程来执行PI的求值操作。求得PI值有两种方法，一种是直接把各个线程每一步所求得的值加到gSum上去，另一种是把各个线程所求得的值加到一个与之对应的全局变量中去。对每个线程i，输出Thread number:I aaaaaa...
Java多线程编程-使用线程的缺点
05-26
使用线程的缺点主要有以下几点： 1. 资源竞争：多个线程共享同一资源时，可能会发生资源竞争的情况，导致数据不一致或者程序出现异常。 2. 上下文切换开销：线程之间的切换需要保存和恢复上下文信息，这个过程需要消耗一定的系统资源，如果线程数量过多，会导致系统性能降低。 3. 线程安全：多个线程同时访问共享资源时，需要考虑线程安全的问题，需要采用锁、同步等机制来保证数据的一致性和正确性，这会增加代码的复杂度。 4. 调试困难：多线程程序的调试比单线程程序复杂，因为多个线程之间的相互影响可能导致程序的错误行为。 5. 可靠性降低：线程之间的协作关系比较复杂，如果不正确地使用线程，可能会导致程序崩溃或者死锁等问题，从而影响程序的可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

青衫客36

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

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

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

打赏作者

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

抵扣说明：

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

余额充值