Question

我正在测试一个pthread程序。

这个程序很简单。主线程创建一个子线程。

主线程和子线程都在队列中运行。

子线程继续扫描队列并以无限循环返回最小元素及其位置。

主线程也在运行一个循环，每次迭代都会删除子线程从队列中计算出的最小元素，并将一些新元素插入到队列的末尾。

最小元素及其位置和队列都被声明为全局变量。

当队列为空时主要结束，它将取消子线程。

这一进展有点像广度优先搜索。

队列实现为带有大小计数器的数组。删除操作实现为替换要被最后一个元素删除的元素，并将大小计数器减一。

此处未使用锁定。但是在运行时，程序会卡住。

更令人惊奇的是，如果我插入一些printf语句来查看状态，它可能会完成。

我想知道是什么导致这个程序无穷无尽？

struct multiblocks_pthread_args {
    volatile int local_e;
    volatile int local_v;
    volatile int local_pos;
    int* Q;
    int* val;
    volatile int* size;
} para;

volatile int update = 0;
void* child_thread ( void* args ) {
    pthread_setcanceltype ( PTHREAD_CANCEL_ASYNCHRONOUS, NULL );
    multiblocks_pthread_args* arglist = ( multiblocks_pthread_args* ) args;
    bindToCore ( 1 );
    int* list = arglist -> Q, * value = arglist -> val;
    while ( true ) {
        int size, e, v, pos;
        do {
            size = * ( arglist->size ), e, v = INF, pos = 0;
            update = 0;
            for ( int i = 0; i < size; i++ ) {
                int vi = value[i];
                if ( vi < v ) {
                    pos = i;
                    v = vi;
                }
            }
        } while ( update );
        if ( size > 0 ) e = list[pos];
        arglist->local_e = e;
        arglist->local_pos = pos;
        arglist->local_v = v;
    }
    return NULL;
}

void main_thread () {
    int size;
    int* Q = ( int* ) malloc ( sizeof ( int ) * NumNode );
    int** hash = ( int** ) malloc ( sizeof ( int* ) * numNode );
    NodeColor* color = ( NodeColor* ) malloc ( sizeof ( NodeColor ) * numNode ); 
    // NodeColor is a enum with 3 values: WHITE, GRAY, BLACK

    memset ( color, 0, sizeof ( NodeColor ) * numNode );

    pthread_t tid;
    para.val = ( int* ) malloc ( sizeof ( int ) * NumNode );
    para.Q = Q;
    para.size = &size;
    pthread_create ( &tid, NULL, child_thread, &para );

    // Only one element is in the queue
    size = 0;
    para.Q[size] = 0;
    para.val[size] = 0;
    hash[0] = &para.val[size]; // hash is used to modify the value of particular element
    ++size;
    color[0] = GRAY;
    while ( true ) {
        int global_e, global_v = INF, global_pos;
        global_e = para.local_e, global_v = para.local_v, global_pos = para.local_pos;
        if ( size == 0 ) break;
        if ( color[global_e] != BLACK ) {
            value[global_e] = global_v, color[global_e] = BLACK;
            if ( size > 0 ) {
                --size;
                para.Q[global_pos] = para.Q[size];
                para.val[global_pos] = para.val[size];
                hash[para.Q[global_pos]] = & para.val[global_pos];
                update = 1;
            }
            for ( int i = 0; i < MAXDEG; ++i ) {
                int ee = ;// new element;
                int vv = ;// value of new element;
                if ( /* if new element is valid */ ) {
                    if ( color[ee] == WHITE ) { // WHITE means ee is not in the queue
                        para.Q[size] = ee;
                        para.val[size] = vv;
                        hash[ee] = &para.val[size];
                        ++size, color[ee] = GRAY;
                    } else {
                        *hash[ee] = vv;
                    }
                    update = 1;
                }
            }
        }
    }
    free ( Q );
    pthread_cancel ( tid );
    printf ( "Computation finishes!!!" );
    return ;
}

Answer 1

这不是僵局，而是竞争条件。

您的挂起的整体结构是，您从索引0处的WHITE项开始，此循环将永远持续：

size = 1;
while (size != 0) {
  if (WHITE) --size;
  for (...) {
    if (WHITE) ++size;
  }
}

此更改的唯一方法是您的子线程将pos设置为除0之外的其他内容。但是你的孩子线程取决于大小大于1，使其超过0.你有你的竞争条件。

我的诊断可能不准确。更清洁的代码会有很大帮助。像Q，e，v这样的名称可以为您节省几次击键次数，但很容易让您失去几天，就像在此示例中一样。你也可以互换使用数字和枚举，这是一种不好的做法。

死锁没有明确的锁定

1 个答案: