如果 main 在 c 中也是一个线程，为什么它不与其他线程一起运行

Question

I read that main() is single thread itself, so when i create 2 threads in my program like this;

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

void* counting(void * arg){
    int i = 0;
    for(i; i < 50; i++){
        printf("counting ... \n");
        Sleep(100);

    }
}

void* waiting(void * arg){
    int i = 0;
    for(i; i < 50; i++){
        printf("waiting ... \n");
        Sleep(100);
    }
}

int main(){
    pthread_t thread1;
    pthread_t thread2;
    pthread_create(&thread1, NULL, counting, NULL);
    pthread_create(&thread2, NULL, waiting, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    int i = 0;
    for(i; i < 50; i++){
        printf("maining ... \n");
        Sleep(1000);
    }


}

Is main really a thread in that case? in that case if in main in sleep for some time, shouldn't the main give the CPU to other threads? Is main a threads itself here? I am confused a bit here. Is there a specific order to main thread execution?

Answer 1

 pthread_join(thread1, NULL);
 pthread_join(thread2, NULL);

You asked the thread to wait until thread1 terminates and then wait until thread2 terminates, so that's what it does.

Answer 2

main() is not a thread but a function, so here's a clear "no" to your initial claim. However, if you read a few definitions of what is a thread, you will find that it is something that can be scheduled, ie an ongoing execution of code. Further, a running program will not be able to actually do anything without "ongoing execution of code" without eg main() as first entrypoint. So, definitely, every code executed by a program is executed by a thread, without exceptions.

BTW: You can retrieve the thread ID of the current thread. Try running that from main() . It will work and give you a value that distinguishes this call from calls from other threads.

Answer 3

I read that main() is single thread itself

No, you have misunderstood. Every C program has a function named main() . C language semantics of the program start with the initial entry into that function. In that sense, and especially when you supply the parentheses, main() , is a function, not a thread.

However, every process also has a main thread which has a few properties that distinguish it from other threads. That is initially the only thread, so it is that thread that performs the initial entry into the main() function. But it is also that thread that runs all C functions called by main() , and by those functions, etc ., so it is not, in general, specific to running only the code appearing directly in the body of main() , if that's what you mean by "main() is a single thread itself".

, so when i create 2 threads in my program like this; [...] Is main really a thread in that case?

There is really a main thread in that case, separate from the two additional threads that it starts.

in that case if in main in sleep for some time, shouldn't the main give the CPU to other threads?

If the main thread slept while either of the other two were alive, then yes, one would expect one or both of the others to get (more) CPU time. And in a sense, that's exactly what happens: the main thread calls pthread_join() on each of the other threads in turn, which causes it to wait (some would say "sleep") until those threads terminate before it proceeds. While it's waiting, it does not contend with the other threads for CPU time, as that's pretty much what "waiting" means. But by the time the main thread reaches the Sleep() call in your program, the other threads have already terminated and been joined, because that's what pthread_join() does. They no longer exist, so naturally they don't run during the Sleep() .

Is main a threads itself here?

There is a main thread, yes, and it is the only one in your particular process that executes any of the code in function main() . Nothing gets executed except in some thread or other.

I am confused a bit here. Is there a specific order to main thread execution?

As already described, the main thread is initially the only thread. Many programs never have more than that one. Threads other than the main one are created only by the main thread or by another thread that has already been created. Of course, threads cannot run before they are created, nor, by definition, after they have terminated. Threads execute independently of each other, generally without any predefined order, except as is explicitly established via synchronization objects such as mutexes, via for-purpose functions such as pthread_join() , or via cooperative operations on various I/O objects such as pipes.