标签: pthreads

我正在尝试创建一个采用字符串形式的线程argv[1]并将其传递给我的函数.这是我试图传递它的代码.

if(pthread_create(&thread1, NULL, getMax, &argv[1]) != 0){
    printf("ERROR createing the thread\n");
    return 1;
}

这是我在pthread_create函数中调用的函数.

void * getMax(void * f){
char * fileName = (char*)f;
printf("%s\n\n",fileName);
}

我相信我的问题是当我将它转换回字符指针时.该printf函数打印出几个随机字符.如果我调用函数传递一个字符串就行了.

pthread_create(&thread1, NULL, getMax, "This Works");

如果有人可以解释如何施放argv[1]它,使其行为像一个非常感激的字符数组.

我是并行计算的新手,所以我正在玩pthread和互斥体.运行以下代码会导致死锁.任何人都可以解释我为什么,以及如何以正确的方式解决这个问题？我的目标是保护成员变量不被交叉写入.非常感谢提前!

#include <pthread.h>
#include <iostream>

class mutex_class
{

    public:
        mutex_class();
        void print_stars(int count);
        void print_dots(int count);

    private:
        pthread_mutex_t mutex;

};

mutex_class::mutex_class()
{
    pthread_mutex_t mutex;
    pthread_mutex_init (&mutex, NULL);
}

void mutex_class::print_stars(int count)
{
    pthread_mutex_lock(&this->mutex);
    for(int i=0; i<count; i++)
    {
        std::cout << "*" << std::flush;
    }
    pthread_mutex_unlock(&this->mutex);
}

void mutex_class::print_dots(int count)
{
    pthread_mutex_lock(&this->mutex);
    for(int i=0; i<count; i++)
    {
        std::cout << "." << std::flush;
    }
    pthread_mutex_unlock(&this->mutex);
}

void* call_dots(void* m)
{
    (*(mutex_class*)m).print_dots(20);
}

void* call_stars(void* m)
{
    (*(mutex_class*)m).print_stars(20);
}

int main()
{
    mutex_class …

我有一个任务,我必须将多个参数传递给C中的线程调用函数.要清楚pthread_create(&threadName, NULL, search_thread, parameter1)是我的线程创建,其中我想为search_thread函数传递更多参数.可能吗？基本上我想要pthread_create(&threadName, NULL, search_thread, parameter1, parameter2,...)

我正在使用pthreads库开发一个C++应用程序.程序中的每个线程都访问一个公共的unordered_map.程序运行速度慢于4个线程而不是1.我评论了线程中的所有代码,并且只留下了标记字符串的部分.单线程执行仍然更快,所以我得出的结论是地图不是问题.之后我在屏幕上打印了线程的ID,它们似乎按顺序执行.

在调用线程的函数中,我有一个while循环,它在一个数组中创建线程,其大小是线程数(让我们说'tn').每次创建线程时,我都会执行for循环来加入它们.(在pthread_join).虽然跑了很多次(不仅仅是4次).

可能有什么不对？

我在C语言编程时学习了一些关于pthreads和性能的知识,我想知道最好的方法是int在数组中添加一个单独的元素(相当大的一个,大约有5000个元素)以及将a乘以int数组中的所有元素的最佳方法.

我尝试并行执行此操作,但没有太大改进.我的并行方法是传递struct包含add/multiply的值以及指向数组的指针.我将此作为论据传递给了pthread_create.在被调用的函数中,我将给定值添加/乘以数组中的所有元素.

我觉得有一种更好的方法可以将数字乘以或添加到数组中的所有5000个元素(或更多).我也听说过那些SIMD命令.这可能有助于这种情况吗？

以下代码是从此站点获取的，并且显示了如何使用互斥锁。它同时实现了pthread_join和pthread_mutex_lock：

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

void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int  counter = 0;

main()
{
   int rc1, rc2;
   pthread_t thread1, thread2;

   /* Create independent threads each of which will execute functionC */

   if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )
   {
      printf("Thread creation failed: %d\n", rc1);
   }

   if( (rc2=pthread_create( &thread2, NULL, &functionC, NULL)) )
   {
      printf("Thread creation failed: %d\n", rc2);
   }

   /* Wait till threads are complete before main continues. Unless we  */
   /* wait …

我以为我认识C和互斥体......显然我没有.

下面的代码,我希望打印地址,等待5秒,然后再次打印相同的地址.

它没有 - 它打印两次相同的地址,但立即,为什么？

我编译代码

>gcc -lpthread foobar.c

我一定不明白一些明显的东西,这是令人尴尬的......

根据Jonathan Leffler和Chris Dodd以及user3629249的建议,我编写了如下代码,同样的问题.这变得非常尴尬......

foob​​ar.c但是:

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


void foobar(pthread_mutex_t *plock) {
    pthread_mutex_lock(plock);
    printf("lock address %p\n", plock);
    fflush(stdout);
    sleep(5);
    pthread_mutex_unlock(plock);
}

int main(void)
{
    pthread_mutex_t *plock;
    pthread_mutexattr_t attr;

    pthread_mutexattr_init(&attr);
    printf("return %d\n", pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED));
    printf("mutex allocated %p\n", plock = malloc(sizeof(pthread_mutex_t)));
    printf("return %d\n", pthread_mutex_init(plock, &attr));
    fork() ? foobar(plock) : foobar(plock);
}

php.exe可以连续运行数周或数月的应用程序运行,而不会崩溃吗？

例如:UDP或HTTP/TCP服务器(或网络)应用程序.我听说它还没有为长时间运行的应用程序开发.我相信我们可以在linux和Windows中使用pthreads/events来进行多线程/并行,以支持为进程生成的负载并开发长时间运行的应用程序.但不确定会有多稳定.任何能够使用pthreads和长期运行的PHP应用程序发表评论并提供开发资源指导的人？

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

#define N_ASS 4

pthread_t tid[N_ASS];
//mutex
pthread_mutex_t mutex;

//variabili condition
pthread_cond_t c_ass[N_ASS], c_pass[N_PASS];



void * checkDoc ()
{
 printf("do stuff\n");
}


int main()
{

 int err;
 int i = 0;

 for(i;i<N_ASS;i++){
    err = pthread_create (&tid[i], NULL, checkDoc(), NULL);
    pthread_cond_wait(&c_ass[i],&mutex);
    }

 for(i=0;i<N_ASS;i++)
    pthread_cond_signal(&c_ass[i]);

 for(i=0;i<N_ASS;i++) {
     err = pthread_join(tid[i],NULL);
     printf("%d joined\n",i);
 }

 printf("End\n");

}

我只想说我是一个刚刚学习的小菜鸟,这是我的第一个问题,如果我必须做别的事情就告诉我,我会做的!所以这是代码,我有一个第一个问题,它使分段错误,我不知道为什么.输出是:

做什么// 1,2,3或4次

分段故障

没别的,我至少跑了20次.

我的互斥类定义如下: -

class Mutex{
    static pthread_mutex_t mutex;
public:
    Mutex(){
        pthread_mutex_init(&mutex, NULL);
        while(pthread_mutex_trylock(&mutex)){
            sleep(2000);
        }
    }
    virtual ~Mutex(){
        pthread_mutex_unlock(&mutex);
        pthread_mutex_destroy(&mutex);
    }
};

我试图应用互斥的函数使用这个类如下: -

void doSomething(){
    Mutex mutex;
    // do something
}

这样,当调用构造函数时,互斥锁被初始化并尝试获取该互斥锁上的锁.当它超出该函数的范围时,它会自动被破坏.

但是如果一个线程锁定了互斥锁,另一个线程会尝试pthread_mutex_init在其上运行,究竟会发生什么？是否会覆盖具有锁定的线程？