pthread_create(3) Library Functions Manual pthread_create(3) pthread_create - POSIX (libpthread -lpthread) #include int pthread_create(pthread_t *restrict thread, const pthread_attr_t *_Nullable restrict attr, typeof(void *(void *_Nullable)) *start_routine, void *_Nullable restrict arg); pthread_create() . start_routine() arg start_routine(). : o pthread_exit(3) pthread_join(3). o start_routine(). pthread_exit(3) return. o ( pthread_cancel(3)). o exit(3) main(). . attr pthread_attr_t pthread_attr_init(3) . attr NULL . pthread_create() thread pthreads . (pthread_sigmask(3)). (sigpending(2)). (sigaltstack(2)). (fenv(3)). 0 ( pthread_getcpuclockid(3)). ( capabilities(7)) ( sched_setaffinity(2)). pthread_create() 0 *thread . EAGAIN . EAGAIN . : RLIMIT_NPROC ( setrlimit(2)) /proc/sys/kernel/threads-max ( proc(5)) /proc/sys/kernel/pid_max ( proc(5)). EINVAL attr. EPERM attr. attributes(7). +------------+------------------------------------+--------------------+ || | | +------------+------------------------------------+--------------------+ |pthread_create()| | MT-Safe | | | | | +------------+------------------------------------+--------------------+ POSIX.1-2008. POSIX.1-2001. pthread_self(3) *thread pthread_create(). pthread_create() -- -- . . pthread_join(3) . . : . . attr ( pthread_attr_setdetachstate(3)). NPTL RLIMIT_STACK " " . pthread_attr_setstacksize(3) attr . RLIMIT_STACK " " : 2 4 POWER Sparc-64. LinuxThreads . POSIX pthreads(7). pthread_create() pthreads. NPTL " ": $ ulimit -s 8192 # The stack size limit is 8 MB (0x800000 bytes) $ ./a.out hola salut servus Thread 1: top of stack near 0xb7dd03b8; argv_string=hola Thread 2: top of stack near 0xb75cf3b8; argv_string=salut Thread 3: top of stack near 0xb6dce3b8; argv_string=servus Joined with thread 1; returned value was HOLA Joined with thread 2; returned value was SALUT Joined with thread 3; returned value was SERVUS 1 ( pthread_attr_setstacksize(3)) : $ ./a.out -s 0x100000 hola salut servus Thread 1: top of stack near 0xb7d723b8; argv_string=hola Thread 2: top of stack near 0xb7c713b8; argv_string=salut Thread 3: top of stack near 0xb7b703b8; argv_string=servus Joined with thread 1; returned value was HOLA Joined with thread 2; returned value was SALUT Joined with thread 3; returned value was SERVUS #include #include #include #include #include #include #include #include struct thread_info { /* Used as argument to thread_start() */ pthread_t thread_id; /* ID returned by pthread_create() */ int thread_num; /* Application-defined thread # */ char *argv_string; /* From command-line argument */ }; /* Thread start function: display address near top of our stack, and return upper-cased copy of argv_string. */ static void * thread_start(void *arg) { struct thread_info *tinfo = arg; char *uargv; printf("Thread %d: top of stack near %p; argv_string=%s\n", tinfo->thread_num, (void *) &tinfo, tinfo->argv_string); uargv = strdup(tinfo->argv_string); if (uargv == NULL) err(EXIT_FAILURE, "strdup"); for (char *p = uargv; *p != '\0'; p++) *p = toupper(*p); return uargv; } int main(int argc, char *argv[]) { int s, opt; void *res; size_t num_threads; ssize_t stack_size; pthread_attr_t attr; struct thread_info *tinfo; /* The "-s" option specifies a stack size for our threads. */ stack_size = -1; while ((opt = getopt(argc, argv, "s:")) != -1) { switch (opt) { case 's': stack_size = strtoul(optarg, NULL, 0); break; default: fprintf(stderr, "Usage: %s [-s stack-size] arg...\n", argv[0]); exit(EXIT_FAILURE); } } num_threads = argc - optind; /* Initialize thread creation attributes. */ s = pthread_attr_init(&attr); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_init"); if (stack_size > 0) { s = pthread_attr_setstacksize(&attr, stack_size); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_setstacksize"); } /* Allocate memory for pthread_create() arguments. */ tinfo = calloc(num_threads, sizeof(*tinfo)); if (tinfo == NULL) err(EXIT_FAILURE, "calloc"); /* Create one thread for each command-line argument. */ for (size_t tnum = 0; tnum < num_threads; tnum++) { tinfo[tnum].thread_num = tnum + 1; tinfo[tnum].argv_string = argv[optind + tnum]; /* The pthread_create() call stores the thread ID into corresponding element of tinfo[]. */ s = pthread_create(&tinfo[tnum].thread_id, &attr, &thread_start, &tinfo[tnum]); if (s != 0) errc(EXIT_FAILURE, s, "pthread_create"); } /* Destroy the thread attributes object, since it is no longer needed. */ s = pthread_attr_destroy(&attr); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_destroy"); /* Now join with each thread, and display its returned value. */ for (size_t tnum = 0; tnum < num_threads; tnum++) { s = pthread_join(tinfo[tnum].thread_id, &res); if (s != 0) errc(EXIT_FAILURE, s, "pthread_join"); printf("Joined with thread %d; returned value was %s\n", tinfo[tnum].thread_num, (char *) res); free(res); /* Free memory allocated by thread */ } free(tinfo); exit(EXIT_SUCCESS); } getrlimit(2), pthread_attr_init(3), pthread_cancel(3), pthread_detach(3), pthread_equal(3), pthread_exit(3), pthread_getattr_np(3), pthread_join(3), pthread_self(3), pthread_setattr_default_np(3), pthreads(7) 3 . . : . 6.18 10 2026 pthread_create(3)