Question

我的代码的目的是执行两个子进程并增加共享变量计数器。每个过程应该增加100万。这是我的代码：

    #include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

typedef struct
{
    int value;
}   shared_mem; 
shared_mem  *counter;

//these next two processes are the ones that increment the counter
process1()
{
    int i=0;
    for(i=0;i<1000000;i++)
        counter->value++;
}

process2()
{
    int i=0;
    for(i=0;i<1000000;i++)
        counter->value++;
}

/*  The Main Body   */

main()
{
    key_t   key = IPC_PRIVATE;  /* shared memory key */ 
    int shmid;  /* shared memory ID */ 
    shared_mem  *shmat1;    

    int pid1;   /* process id for child1 */
    int pid2;   /* process id for child2 */


    /* attempts to attach to an existing memory segment */

    if (( shmid = shmget(key, sizeof(int), IPC_CREAT | 0666)) < 0)
    {
        perror("shmget");
         return(1);
    }

    /*attempts the shared memory segment    */

    if((counter = (shared_mem *)shmat(shmid, NULL, 0)) == (shared_mem *) -1)
    {
        perror("shmat");    
        return(1);
    }

    /*initializing shared memory to 0 */ 
    counter->value = 0;

    pid1=fork();
    /* fork process one here */
    if(pid1==0)
    {
        printf("I am child 1 with PID %d\n", getpid());
        process1();
    }
    else
    {
        pid2=fork();

        if(pid2==0)
        {
            printf("I am child 2 with PID %d\n", getpid());
            process2();
        }
        else
        {
            wait(NULL);
            printf("I am parent with PID %d\n", getpid());
            printf("Total counter value is: %d\n", counter->value);
        }

    }


    /*deallocate shared memory */
    if(shmctl(shmid, IPC_RMID, (struct shmid_ds *)0)== -1)
    { 
        perror("shmctl");
        return(-1);
    }
    return(0);

}

计数器产量徘徊在100万左右，但不应该徘徊在200万左右？我想我不了解流程增加的方式。非常感谢，如果代码太长，我很抱歉，但我不确定我可以包含什么以及我可以排除什么。

Answer 1

变量增量本身不是原子的;除非另有说明，否则编译器可以生成如下代码：

load counter->value in a register
increment the register
move the incremented value back to counter->value

这正是gcc在禁用优化的情况下生成的代码类型：

mov rax, QWORD PTR counter[rip]   ; find out the address of counter->value
mov edx, DWORD PTR [rax]          ; get its content in edx
add edx, 1                        ; increment edx
mov DWORD PTR [rax], edx          ; move it back to counter->value

（尽管您可能会遇到竞争条件，即使生成的增量程序集只是一条指令 - 例如，即使是多核计算机上x86 is not atomic上的直接inc DWORD PTR[rax]，除非它有lock前缀。）

现在，如果你有两个线程不断尝试同时增加变量，那么大多数情况下你会有一系列类似于此的操作：

Thread A                               Thread B
load counter->value in a register
                                       load counter->value in a register
                                       increment the register
increment the register
move the register to counter->value
                                       move the register to counter->value

由于两个增量都发生在从相同值开始的单独寄存器中，因此最终结果是counter->value看起来只增加一次，而不是两次（这只是一个可能的例子，你可以设想很多其他可能的序列可能会跳过任意多的增量 - 假设线程1在加载和存储之间挂起，而第二个线程继续进行多次迭代。）

解决方案是使用原子操作对共享值进行操作;在gcc上，你有几个atomic builtins可用，它扩展为正确的汇编代码，执行描述的操作 atomically ，即没有交错的风险，如上所述。

在这种特殊情况下，您应该使用counter->value++之类的内容替换__sync_add_and_fetch(&counter->value, 1)。生成的代码更改为

mov rax, QWORD PTR counter[rip]    ; find out the address of counter->value
lock add    DWORD PTR [rax], 1     ; atomically increment the pointed value

你应该看到计数器确实按预期达到2000000。

请注意，原子操作非常有限，因为CPU通常仅在有限数量的类型（通常是小于本机字大小的整数）上支持此类操作，并且只有少数基元可用或易于组装（例如，原子交换，原子比较和交换，原子增量等）。因此，每当您需要保证某些任意代码块始终以原子方式执行时，您必须使用互斥锁和其他同步原语（通常通过原子操作构建）。

为什么我的孩子没有给我正确的＃34;正确的＆＃34;结果如何？

1 个答案: