c – Pthread_mutex_lock返回访问错误

我正在编写一个读取和处理大量数据的程序.为了加快这个过程,我使用C的Pthreads库实现了多线程读取/处理.但是当我在我的互斥锁上调用pthread_mutex_lock(& lock1)时,我的程序错误导致我在lock1的地址上出现“访问冲突读取位置”错误.我需要在类的方法上运行这些线程,这需要在pthread库的限制范围内进行一些操作,并且它在某种操作中使我犯了错误.下面是我的代码的缩写版本,对不起tl;博士.在不遗漏任何对多线程至关重要的部分的情况下尽可能缩短它：

#include "pthread.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <Windows.h>


/*Ideally I need to create one instance of this object that has the run_stuff method 
being executed by two different threads.  I need both threads to have access to the 
same private variables, and have ensured that those variables won't be accessed at the 
same time. That is the end goal of my multithreading*/

class test_obj {
public:
    test_obj();
    void run_stuff(int); //the method I want to run on two different threads using the same private variables
private:
    int count;
    void switch_gate1();//switches the value of gate 1
    void switch_gate2();
    bool test_gate1(int); //checks to see if gate 1 equals thread id
    bool test_gate2(int);
    bool gate1, gate2; //can only be accessed under a locked mutex
    pthread_mutex_t lock1, lock2;
};

/*This structure is what I pass to pthread_create*/
struct thread_args { //arguements passed to a thread when it is created
    thread_args() {a = new test_obj;}; //constructor: create new test_obj instance
    test_obj *a; //pointer to a test_obj instance, I think both threads receive a pointer to the same instance
    int t_id; //ID of thread being created
};

class thread_helper { //managing function to create threads and call run_stuff method
public:
    thread_helper() {args = new thread_args;};
    void my_method(); //called from main, creates threads and runs them
private:
    thread_args *args; //pointer to a thread_args obj
    static void* execute(void *ptr); //method to be run by created threads
    pthread_t m_thread1, m_thread2; //the two threads
};

int main() {
    thread_helper c; 
    c.my_method();
    return 0;
}

test_obj::test_obj() {
    count = 0; //not important right now, test variable
    gate1 = 0; //thread 0 gets first access
    gate2 = 0; //thread 0 gets first access
}

void thread_helper::my_method() {
    int error_code;
    thread_args *a, *b;
    *a = *b = *args;
    a->t_id = 0;
    b->t_id = 1;
    error_code = pthread_create(&m_thread1, NULL, &thread_helper::execute, (void*)a); //create thread 0 to run execute method
    assert(0 == error_code); //check for success
    error_code = pthread_create(&m_thread2, NULL, &thread_helper::execute, (void*)b);
    assert(0 == error_code);
    error_code = pthread_join(m_thread1, NULL);//wait for thread 0
    assert(0 == error_code);
    error_code = pthread_join(m_thread2, NULL); //wait for thread 1
    assert(0 == error_code);
}

void* thread_helper::execute(void *ptr) {
    thread_args *b = (thread_args*)ptr;//recast ptr back into thread_args type
    int t_id = b->t_id;//save thread id
    b->a->run_stuff(t_id);//access test_obj object from thread_args (should be same object for both threads) and run method
    return NULL;
}

void test_obj::run_stuff(int t_id) {
    for(int i = 0; i < 2; i++) { //run twice (give a chance for threads to flip flop)
    //-----Part 1
    while(!test_gate1(t_id)){//while not allowed to proceed
        Sleep(500);//sleep
    }
    printf("thread %d reporting in\n", t_id);//thread has gained access to part 1, print id
    switch_gate1();//allow opposite thread in
    //-----Part 2
    while(!test_gate2(t_id)){//wait for access to part 2
        Sleep(500);
    }
    //count++; //just a dummy place for now, will be used later to check access
    switch_gate2();//allow opposite thread in
    }
}

bool test_obj::test_gate1(int t_id) {//returns true if id of calling thread matches value of gate 1
//a return value of true means a thread is allowed to proceed, false otherwise
    pthread_mutex_lock(&lock1);**//secure access to gate THIS IS WHAT ERRORS OUT**
    if(t_id == gate1){//check gate
        pthread_mutex_unlock(&lock1);//release gate
        return true;//return
    }
    else {
        pthread_mutex_unlock(&lock1);
        return false;
    }
}

bool test_obj::test_gate2(int t_id) {
    pthread_mutex_lock(&lock2);
    if(t_id == gate2){
        pthread_mutex_unlock(&lock2);
        return true;
    }
    else {
        pthread_mutex_unlock(&lock2);
        return false;
    }
}

/*Switch gate functions are designed to obtain access to the boolean gate (prevent the opposing thread from checking the gate by means of mutex), then switch the value of the boolean gate and release the gate for the other thread to check.*/
void test_obj::switch_gate1() {
    pthread_mutex_lock(&lock1);//secure access to gate
    gate1 = !gate1; //flip gate
    pthread_mutex_unlock(&lock1); //release gate
}

void test_obj::switch_gate2() {
    pthread_mutex_lock(&lock2);
    gate2 = !gate2;
    pthread_mutex_unlock(&lock2);
}

抱歉格式化.任何人都知道为什么该锁具有访问冲突错误？我试过把它放到任何地方.私人,公共甚至全球作为最后的手段.他们都给出了同样的错误.提前致谢.

编辑：修复了将我的thread_args变量传递给pthreads_create时出错的问题.在此之后按预期工作并初始化/销毁修复.

解决方法:

您似乎没有初始化您的互斥锁.我没看到你在哪里声明你的互斥体.

在test_obj中声明变量：

pthread_mutex_t lock1;
pthread_mutex_t lock2;

将其添加到test_obj构造函数中：

test_obj::test_obj() {
    ...
    lock1 = PTHREAD_MUTEX_INITIALIZER;
    lock2 = PTHREAD_MUTEX_INITIALIZER;
}

将其添加到test_obj析构函数中：

test_obj::~test_obj() {
    pthread_mutex_destroy(&lock1);
    pthread_mutex_destroy(&lock2);
}

标签：access-violation,c,multithreading,pthreads,mutex
来源： https://codeday.me/bug/20190901/1784584.html