多线程并发耗时测试

最新推荐文章于 2022-07-29 09:47:06 发布
最新推荐文章于 2022-07-29 09:47:06 发布
阅读量226 收藏
点赞数
原文链接：http://www.cnblogs.com/gogly/archive/2012/09/27/2704967.html
版权

测试环境：24CPU 2.4GHz ，32G内存

实验数据：

mutex.c

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        pthread_mutex_lock(&mutex);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

 

　　SPIN_UPDATE:

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
pthread_spinlock_t mylock;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

int newlock(pthread_spinlock_t *lock){ 
__asm__(
//eax清零，记录当前lock次数
"xor %%eax,%%eax\n\t"
//ecx清零，记录总的lock次数
"xor %%ecx,%%ecx\n\t"
//记录加锁次数
"1:incl %%ecx\n\t"
//记录当前加锁次数
"incl %%eax\n\t"
//锁总线，开始加锁，rdi寄存器存储的是lock变量的地址
"lock decl (%%rdi)\n\t"
//加锁不成功
"jne 2f\n\t"
//加锁成功，将锁总线次数作为返回值返回
"movl %%ecx,%%eax\n\t"
"leave\n\t"
"retq\n\t"
"nop\n\t"
"nop\n\t"
//pause跳转标签
"5:pause\n\t"
"4:pause\n\t"
"3:pause\n\t"
"2:pause\n\t"
//探测锁是否可用
"cmpl $0x0,(%%rdi)\n\t"
//锁可用，重新加锁
"jg 1b\n\t"
//加锁次数与4取模
"and $0x3,%%eax\n\t"
//根据结果进行跳转
"cmpl $0x0,%%eax\n\t"
"je 2b\n\t"
"cmpl $0x1,%%eax\n\t"
"je 3b\n\t"
"cmpl $0x2,%%eax\n\t"
"je 4b\n\t"
"je 5b\n\t"
"nop\n\t"
"nop\n\t"
:
:"D"(lock)
:"%eax","%ecx","%edx");
}

int sim_spin_lock(pthread_spinlock_t *lock){
__asm__(
//eax清零，记录当前lock次数
"xor %%eax,%%eax\n\t"
//ecx清零，记录总的lock次数
"xor %%ecx,%%ecx\n\t"
//记录加锁次数
"1:incl %%ecx\n\t"
//记录当前加锁次数
"incl %%eax\n\t"
//锁总线，开始加锁，rdi寄存器存储的是lock变量的地址
"lock decl (%%rdi)\n\t"
//加锁不成功
"jne 2f\n\t"
//加锁成功，将锁总线次数作为返回值返回
"movl %%ecx,%%eax\n\t"
"leave\n\t"
"retq\n\t"
"nop\n\t"
"nop\n\t"
//pause跳转标签
"2:pause\n\t"
//探测锁是否可用
"cmpl $0x0,(%%rdi)\n\t"
//锁可用，重新加锁
"jg 1b\n\t"
"jmp 2b\n\t"
"nop\n\t"
"nop\n\t"
:
:"D"(lock)
:"%eax","%ecx","%edx");
}

/*
int spinlock_internal(pthread_spinlock_t *lock)
{

int ret = 0;
__asm__ ("n"
"1:lock; decl %0nt"
"jne 2fnt"
"movl $0, %1nt"
"jmp 4fnt"
"n"
".subsection 2nt"
".align 16nt"
"2:tmovl $5, %%ecxnt"
"3:trep; nopnt"
"cmpl $0, %0nt"
"jg 1bnt"
"decl %%ecxnt"
"jnz 3bnt"
"jmp 5fnt"
".previousnt"
"5:tmovl $1, %1nt"
"4:tnop"
: "=m" (*lock), "=r"(ret) : "m" (*lock) : "%ecx");

return ret;

}

int nongreedy_spinlock(pthread_spinlock_t *lock)
{

int rc = 0;

rc = spinlock_internal(lock);
while (rc) {
sched_yield();
rc = spinlock_internal(lock);
}
return 0;

}
*/
void *func(void *arg){
        int i,j, k, m,t;
        for( i=0; i< loop_count; i++){
        newlock(&mylock);
                g_count++;
                //下面这几句代码之间有很强的依赖性，流水hazard比较多
                //每句代码都要依赖上一句的执行结果，而且都是store操作
                //用于模仿实际情况中的临界区代码
                for( t=0; t< code_len; t++){
                        j = k;
                        m = j;
                        k = m;
                        m = j+1;
                        k = m+2;
                        j = m+k;
                }
                pthread_spin_unlock(&mylock);
        }
        return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
        struct timeval tvEnd;
        gettimeofday(&tvEnd,NULL);
        return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
        if(argc < 3){
                return 0;
        }
        int i;
        unsigned long ms_time = 0;
        struct timeval tvStart;
        thread_count = atoi(argv[1]);
        loop_count = atoi(argv[2]);
        code_len = atoi(argv[3]);
        pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
        pthread_spin_init(&mylock, 0);
        gettimeofday(&tvStart,NULL);
        for(i=0; i<thread_count; i++){
                pthread_create(&tid[i], NULL, func, NULL);
        }
 void *tret;
        for(i=0; i<thread_count; i++){
                int ret = pthread_join(tid[i], &tret);
                if(ret != 0){
                printf("cannot join thread1");
                }
        }
        ms_time = get_process_time(&tvStart);
        fprintf(stderr, "time:%ld\n",  ms_time);
        return 0;
}

 

　　sem：

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#include<semaphore.h>

#define MAX_LOOP 1000000
#define CODE_LEN 10
sem_t sems;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        sem_wait(&sems);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        sem_post(&sems);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    sem_init(&sems,0,0);
        sem_post(&sems);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}
　　spin:

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
pthread_spinlock_t mylock;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        pthread_spin_lock(&mylock);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        pthread_spin_unlock(&mylock);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    pthread_spin_init(&mylock, 0);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

 

　　rwlock:

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;
pthread_rwlock_t mutex = PTHREAD_RWLOCK_INITIALIZER;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
         pthread_rwlock_wrlock(&mutex);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
         pthread_rwlock_unlock(&mutex);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

 

　　

实验结果：   

　　loop循环1000000，code_len：10次，线程数量：1,4,8,16,20,24,30,40,50； 时间单位：ms

               

1.00 4.00 8.00 16.00 20.00 24.00 30.00 40.00 50.00  
81.00 1660.00 3177.00 6090.00 6720.00 8180.00 11396.00 14798.00 18253.00 mutex
93.00 2951.00 3644.00 9904.00 13312.00 20219.00 33122.00 44787.00 52194.00 rwlock
82.00 1447.00 3076.00 7543.00 8998.00 10895.00 13797.00 21466.00 31165.00 spin
85.00 2536.00 4672.00 12793.00 16704.00 19105.00 24624.00 28932.00 33452.00 sem
91.00 1125.00 3173.00 7224.00 9099.00 10742.00 13860.00 22162.00 30361.00 spin_update-sim
82.00 1448.00 2749.00 5478.00 4410.00 4585.00 6059.00 6924.00 8545.00 spin_update-new

转载于:https://www.cnblogs.com/gogly/archive/2012/09/27/2704967.html

weixin_30294709
关注
C++多线程并发基础入门教程
南风fahaxiki
09-16 1093
线程：线程是操作系统能够进行CPU调度的最小单位，它被包含在进程之中，一个进程可包含单个或者多个线程。可以用多个线程去完成一个任务，也可以用多个进程去完成一个任务，它们的本质都相当于多个人去合伙完成一件事。多线程并发：多线程是实现并发(双核的真正并行或者单核机器的任务切换都叫并发）的一种手段，多线程并发即多个线程同时执行,一般而言，多线程并发就是把一个任务拆分为多个子任务，然后交由不同线程处理不同子任务,使得这多个子任务同时执行。
详解Python多线程Selenium跨浏览器测试
09-21
3. **多线程并发执行**：为每个浏览器创建一个线程，并同时启动这些线程，从而实现多线程并发测试。 4. **异常处理**：如果未能成功创建WebDriver实例，则终止程序执行。 #### 总结 通过上述示例，我们了解了如何...
统计多线程程序的耗时
gunsmoke的专栏
05-26 1529
package study; import java.util.concurrent.TimeUnit; public class Test { public static class myThread extends Thread { int sleepSeconds; public myThread(String name,int seconds) { this.setName(name); this.sleepSeconds = seconds; } @Overrid
使用Junit进行耗时多线程测试
MEdwardM的专栏
03-16 1393
1、引言 有个需求要求将对一个接口进行并发测试，查看是否符合需求，由于习惯使用Junit进行测试，所以就写了以下操作 @Test public void testsend(){ final AtomicLong l = new AtomicLong(0); long begin = System.currentTimeMillis();
多线程：耗时操作
CG-L 的技术博客
03-24 482
// // ViewController.m // 01-耗时操作 // // Created by gzxzmac on 16/1/28. // Copyright © 2016年 gzxzmac. All rights reserved. //#import "ViewController.h"@interface ViewController ()@end@implementation
多线程下的Sleep消耗时间片记录
shigzhu的专栏
07-29 326
多线程下的时间片消耗示例
linux多线程 测时间,Linux 下多线程进程的检测方法
weixin_36377516的博客
05-07 235
引言之前说到在 Linux 下使用 prozilla 进行下载加速，其中一个原因就是 prozilla 是多线程程序，可以同时打开多个连接，而 wget 不是一个多线程的程序。我多想了一下，那怎么判断一个程序进程是单线程还是多线程的？根据 /proc/PID/task 下子目录个数来判断一个程序进程是否是多线程下面来进行测试验证下：1、使用 wget 下载一个文件，相关输出如下：[root@iZ2...
python多线程并发及测试框架案例
09-18
在实际应用中，多线程并发处理常用于I/O密集型任务，如网络请求、文件读写等。然而，由于Python的全局解释器锁（GIL）的存在，多线程在CPU密集型任务上可能无法充分利用多核处理器的优势。因此，对于CPU密集型任务，...
利用curl 多线程 模拟 并发的详解
12-19
在PHP中，我们可以利用`curl`的多线程功能来实现并发请求，提高效率，避免逐个请求的耗时。本文将详细讲解如何利用`curl`的多线程功能模拟并发。 首先，我们需要了解PHP中的`curl`多线程函数： 1. `curl_multi_...
IOS开发-多线程队列测试代码
08-29
在iOS开发中，多线程技术是至关重要的，它能够帮助开发者实现应用程序的高效执行，尤其是在处理耗时操作时，避免UI线程被阻塞，提高用户体验。本篇主要探讨的是多线程队列的使用，特别是GCD（Grand Central Dispatch...
多线程效率测试
weixin_33716941的博客
03-08 223
本文首发于知乎 首先要说明IO密集型任务和计算密集型任务的区别 IO指input output，IO密集型任务包括文件读写（磁盘IO）、网页请求（网络IO）等。这类任务计算量较小，有比较多的等待时间，用多线程可以较大提高运行效率 计算密集型任务是指CPU计算占据主要运行时间，这类任务使用python多线程无法提高效率 下面分为CPU密集型任务、文件读写、网络请求三部分测试多线程对程序运行效率的...
java多线程测试性能，总线程使用总时间。
weixin_30307267的博客
03-21 221
前段时间在做java多线程，然后涉及到了一个效率的问题。 　　java多线程中，所有线程执行完毕，总共使用多少时间呢？ import java.util.concurrent.CountDownLatch; countDwonlatch提供了最常用的一些测试方法。 创建一个countDownLatch对象： 　　 CountDownLatch countD...
多线程
zzl429556205的专栏
12-05 121
什么情况下需使用多线程 有连续的操作，并耗时较长 为了等待网络或文件响应等，需要耗费大量时间运行 为什么使用多线程 从用户角度，是为了得到更好的系统服务；从服务角度，是为了使任务尽快完成，能更有效的利用系统资源。 什么是线程 一个程序可以同时执行多个任务，通常每个任务就是一个线程。（线程间共享变量） 开启线程方式 实现Runnable接口，或者继承Thread类（通过...
多线程测试用例等待打印线程中结果
qq_30920479的博客
12-02 1万+
@Test public void executeTeste() { int page = (100 + 10)/10; StringBuffer st = new StringBuffer(); final CountDownLatch countDown = new CountDownLatch(page); ...
linux-pthread-多线程编程
zhang14916的博客
07-13 429
线程按照其调度者可以分为用户级线程和核心级线程两种 用户级线程主要解决的是上下文切换的问题，它的调度算法和调度过程全部由用户自行选择决定，在运行时不需要特定的内核支持； 我们常用基本就是用户级线程，所以就只总结一下POSIX提供的用户级线程接口； 基本线程操作相关的函数：1线程的建立结束 2线程的互斥和同步 3使用信号量控制线程 4线程的基本属性配置 基本线程操作： 函数 说明 函数声明 返回值 参数 pthread_start() 创建线程开始运行相关...
Java统计多线程执行完毕后的总耗时(CountDownLatch)
弹弹霹雳的博客
11-22 4032
关于计算多线程并发执行的总耗时，可以使用CountDownLatch类的await()方法和countDown()方法来实现
线程阻塞与多线程计数器
w_t_y_y的博客
10-20 896
一、介绍： 1、java为顺序执行代码，如 package com.demo.controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class TestController { @RequestMapping("/test"
Java多线程——获取多个线程任务执行完的时间
热门推荐
学习印记 Learning imprint
06-24 2万+
问题最近我在处理一批数据，用多线程来处理，我想知道大概多久能处理完。比如我先用多线程处理 100 条数据，统计下用时，然后根据总的数据量就可以大概估算出处理完这批数据要多久。使用 CountDownLatch 计时思路：用两个 CountDownLatch 倒计时锁：开始计时锁，任务结束计时锁。开始计时锁在子线程任务开始时通过 await() 阻塞所有子线程，然后在主线程中通过 CountDownL
MFC多线程编程：实现耗时操作并发与通信
MFC多线程编程是一种在Microsoft Foundation Classes (MFC)环境中进行高效并发处理的技术。在传统的单线程应用中，如前面提到的基于对话框的CSingleThreadDlg程序，当遇到耗时操作如延时6秒时，由于程序执行被阻塞，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值