许多编译器优化都基于这样的假设：如果通过左值标识的存储位置被导致或观察到持有某个值，那么在没有任何证据表明存储可能受到干扰的情况下，后续的观察将产生相同的值。除了一些最低要求之外，标准放弃管辖权，作为“实现质量”问题，关于什么形式的证据的问题，一个实现将承认为指示这种干扰的可能性。
如果一个左值有一个volatile限定符，这通常会被解释为要求编译器将与该特定左值相关联的存储视为受到外部更改或观察而不通知。在大多数编译器上，这些编译器被设计为适合低级编程任务，而不是基于clang或gcc，在对对象的两次访问之间发生的对 anything 的volatile write将被视为该对象的状态可能以编译器无法预期理解的方式被观察或修改的证据。然而，clang和gcc两者，将标准放弃对实施质量问题的管辖权视为暗示所有可能的处理都是同样好的，因此两者都故意对潜在干扰的证据视而不见。当使用clang或gcc时，如果存储位置可能通过clang或gcc不理解的方式更改，则必须：
1.在整个程序中，使用C11中添加的“原子”类型，* 独占地 * 引用存储位置。
1.使用volatile限定的左值独占地访问存储位置。
1.在任何使用“普通”左值读取存储的尝试之前和之后，使用“内存屏障”或“内存清除”指令 * 和 * 确保在这些指令之间没有任何东西可以改变存储的值。即使读取可以产生存储在两个内存清除或内存屏障指令之间的任何值，gcc（可能还有clang）有时会以一种与存储器可能 * 曾经 * 保存的任何值不一致的方式运行。例如，给定int temp1 = *p;，gcc有时会通过将使用temp的位置重写为使用*p来消除对temp1的需要。
根据程序需要做什么，上面的任何一种可能是最实用的方法，但是应该记住所有三种可能性。

好吧，经过一些搜索，感谢@Jérôme Richard提供的建议，我设法消除了while循环的需要，因为布尔变量初始化为true，所以优化为while(true)。显然，在共享内存空间中修改它们并不会阻止GCC优化它们。我使用了信号，特别是kill()和sigwait()函数，分别发送和等待信号。
编辑：正如@Brendan所指出的，使用fork（）的代码实际上更慢，这也是因为我提交的平台总结了所有进程的时间。无论如何，感谢大家的帮助。
最后的代码如下：

#define _SVID_SOURCE

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdbool.h>
#include<sys/wait.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<assert.h>
#include<signal.h>

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")

#define buf_size 0x10000

#define acknowledge_read SIGUSR1
#define can_swap SIGUSR2

long long somma(FILE *__restrict__ f){
    size_t size_read;
    long long sum=0;
    int current=0, neg=0, temp=0;

    int fd=fileno(f);
    char c;

    key_t shm_key=ftok("bigsomma_async.c", 65);
    if(shm_key==-1){
        perror("ftok");
    }

    //set up the various pointers for shared memory
    size_t *size_read_ptr;
    char* buf_1;
    char* buf_2;
    char** buf_1_ptr;
    char** buf_2_ptr;

    //allocate sequentially for size, two buffers, pointers to buffers
    int shmid=shmget(shm_key, 
                                sizeof(size_t)+
                                sizeof(char)*buf_size+
                                sizeof(char)*buf_size+
                                sizeof(char*)+
                                sizeof(char*)
                            , IPC_CREAT | 0777);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

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

    //set up the pointers to the respective location
    size_read_ptr=(size_t*)(shared_mem);
    buf_1=(char*)(size_read_ptr+1);
    buf_2=(char*)(buf_1+buf_size);
    buf_1_ptr=(char**)(buf_2+buf_size);
    buf_2_ptr=(char**)(buf_1_ptr+1);

    *size_read_ptr=1;
    *buf_1_ptr=buf_1;
    *buf_2_ptr=buf_2;

    //set the signals to capture (SIGUSR1 and SIGUSR2)
    sigset_t set;
    sigemptyset(&set);  //clear the set of signals
    sigaddset(&set, can_swap);  //add the two signals
    sigaddset(&set, acknowledge_read);
    sigprocmask(SIG_BLOCK, &set, NULL); //set so that the signals get intercepted and blocked

    int none;   //to capture the signals, do not need really in this case, only for correct usage of sigwait

    pid_t pfork=fork();
    if(!pfork){
        pid_t ppid=getppid();
        while(*size_read_ptr!=0){

            sigwait(&set, &none);   //wait for the size to be acknowledged from the parent
            *size_read_ptr=read(fd, buf_2, buf_size);

            sigwait(&set, &none);   //wait for the parent to parse the input

            char* tmp=*buf_1_ptr;       //swap the buffers
            *buf_1_ptr=*buf_2_ptr;
            *buf_2_ptr=tmp;

            kill(ppid, can_swap);       //tell the parent that he can start parsing
        }
        exit(0);
    }else{
        kill(pfork, acknowledge_read);  //send the initial signals so the child doesn't hang
        kill(pfork, can_swap);

        int size_read;
        while(*size_read_ptr!=0){
            sigwait(&set, &none);   //wait for the read and swap to complete

            size_read=*size_read_ptr;
            //tell the child that the size has been acquired, and another read can be performed while the input is processes
            kill(pfork, acknowledge_read);

            //parsing the numbers
            for(current=0; current<size_read; current++){
                c=(*buf_1_ptr)[current];
                if(c>='0'){
                    temp*=10;
                    temp+=c-'0';
                }else if(c=='-'){
                    neg=-1;
                }else{
                    sum+=temp*neg;
                    temp=0;
                    neg=1;
                }
            }

            //tell the child that the buffers can now be swapped
            kill(pfork, can_swap);
        }

    }
    wait(NULL);

    shmdt(shared_mem);
    shmctl(shmid, IPC_RMID, NULL);

    return sum+temp*neg;

}

字符串