自学教程：C++ sthread_create函数代码示例

static void test_parallel(void){	sthread_t st[2];	sc_t sc[2];	int p[2];	void *ret;	if (pipe(p) == -1)		err(1, "pipe()");	sc_init(&sc[0]);	sc_fd_add(&sc[0], p[0], PROT_READ | PROT_WRITE);	if (sthread_create(&st[0], &sc[0], parallel_read, (void*) (long) p[0]))		err(1, "sthread_create()");	sc_init(&sc[1]);	sc_fd_add(&sc[1], p[1], PROT_READ | PROT_WRITE);	if (sthread_create(&st[1], &sc[1], parallel_write, (void*) (long) p[1]))		err(1, "sthread_create()");	if (sthread_join(st[0], &ret) == -1)		err(1, "sthread_join()");	if (sthread_join(st[1], NULL) == -1)		err(1, "sthread_join()");	if (ret != (void*) 0x666)		errx(1, "ret is %p", ret);	close(p[0]);	close(p[1]);}

int main(int argc, char **argv){  int counter0 = 0;  int c1, c2;  sthread_init();  if (sthread_create(thread_1, (void*)0, 10) == NULL) {    printf("sthread_create failed/n");    exit(1);  }  if (sthread_create(thread_2, (void*)0, 1) == NULL) {    printf("sthread_create failed/n");    exit(1);  }  printf("created threads/n");  for(; counter0 < 30000000; counter0++);  c1 = counter1;  c2 = counter2;  printf("1: %i, 2: %i/n", c1, c2);  printf("2/1: %f/n", ((float)c2)/c1);  if (c2/c1 >= 6 && c2/c1 <= 14)    printf("PASSED/n");  return 0;}

int main(int argc, char **argv){  printf("Testing sthread_create, impl: %s/n",	 (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");	  sthread_init();      if (sthread_create(thread1, (void*)1, 10) == NULL) {    printf("sthread_create failed/n");    exit(-1);  }      if (sthread_create(thread2, (void*)1, 10) == NULL) {    printf("sthread_create failed/n");    exit(-1);  }  printf("in main/n");  sthread_sleep(10000);    printf("/ntwo threads runqueue active in priority 10/n");  sthread_dump();  sthread_sleep(10000);  printf("/ntwo threads runqueue active in priority 10/n");  sthread_dump();  printf("out main/n");  return 0;}

int main(int argc, char **argv){  int j;   int count = argc > 1 ? atoi(argv[1]) : 100;   printf("Testing time slice and mutexes, impl: %s/n",      (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");   sthread_init();   if (sthread_create(thread_1, (void*)count, 1) == NULL) {      printf("sthread_create failed/n");      exit(1);   }   if (sthread_create(thread_2, (void*)count, 1) == NULL) {      printf("sthread_create failed/n");      exit(1);   }   printf("created two threads/n");   printf("if this is the last line of output, time slices aren't working!/n");   while(!t1_complete || !t2_complete);   printf("PASSED/n");   return 0;}

int main(void){        printf("executing main function yeasss!!!!!!!/n");        sthread_t p,q,r;        sthread_mutex_init(&m);        sthread_create(&p,f1,NULL);        sthread_create(&q,f2,NULL);        sthread_create(&r,f3,NULL);        sthread_join(-1);        printf("/nmain finished ans: %d /n",sum);        return 0;}

/* * The main function starts the two producers and the consumer, * the starts the thread scheduler. */int main(int argc, char **argv) {    queue = new_bounded_buffer(DEFAULT_BUFFER_LENGTH);    sthread_create(producer, (void *) 0);    sthread_create(producer, (void *) 1);    sthread_create(consumer, (void *) 0);    /*     * Start the thread scheduler.  By default, the timer is     * not started.  Change the argument to 1 to start the timer.     */    sthread_start(1);    return 0;}

/* * Runs four different threads that return at different times in order * to ensure that they all terminate properly without error. */int main(int argc, char **argv) {    int a = 1;    int b = 2;    int c = 3;    int d = 4;    /* Running threads */    sthread_create(test, &a);    sthread_create(test, &b);    sthread_create(test, &c);    sthread_create(test, &d);    sthread_start();    return 0;}

int main(int argc, char **argv){  void *ret;  int i;  printf("Testing sthreads, impl: %s/n",	 (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");	  sthread_init();  mon1 = sthread_monitor_init();  mon2 = sthread_monitor_init();      if (sthread_create(thread0, (void*)1, 10) == NULL) {    printf("sthread_create failed/n");    exit(-1);  }  sthread_monitor_enter(mon1);  for (i = 0; i < NUMBER; i++){    if ((thr[i] = sthread_create(thread1, (void*)i, 10)) == NULL) {      printf("sthread_create failed/n");      exit(-1);    }    sthread_yield();  }  for (i = 0; i < NUMBER; i++){    sthread_monitor_wait(mon1);  }      printf("in main/n");    sthread_monitor_exit(mon1);    sthread_sleep(10000);  sthread_monitor_enter(mon2);  sthread_monitor_signalall(mon2);  sthread_monitor_exit(mon2);    for (i = 0; i < NUMBER; i++){    sthread_join(thr[i], &ret);  }  printf("/nSUCCESS in creating %i threads/n", NUMBER);  printf("out main/n");  return 0;}

static void rarch_main_data_thread_init(void){   data_runloop_t *runloop  = rarch_main_data_get_ptr();   if (!runloop)      return;   runloop->lock            = slock_new();   runloop->cond_lock       = slock_new();   runloop->overlay_lock    = slock_new();   runloop->cond            = scond_new();   runloop->thread    = sthread_create(data_thread_loop, runloop);   if (!runloop->thread)      goto error;   slock_lock(runloop->lock);   runloop->thread_inited   = true;   runloop->alive           = true;   runloop->thread_code     = THREAD_CODE_ALIVE;   slock_unlock(runloop->lock);   return;error:   slock_free(runloop->lock);   slock_free(runloop->cond_lock);   slock_free(runloop->overlay_lock);   scond_free(runloop->cond);}

int main(int argc, char **argv){    int i;    long ret;    sthread_t testers[NTHREADS];    srand(0);	/* init the workload generator */    cacheinit();  /* init the buffer */    /* init blocks */    for (i = 0; i < NBLOCKS; i++) {        memcpy(blockData[i], (char *) &i, BLOCKSIZE);    }    /* start the testers */    for(i = 0; i < NTHREADS; i++) {        sthread_create(&(testers[i]), &tester, i);    }    /* wait for everyone to finish */    for(i = 0; i < NTHREADS; i++) {        ret = sthread_join(testers[i]);    }    printf("Main thread done./n");    return ret;}

int main(int argc, char **argv){	int checks;		printf("Testing sthread_mutex_*, impl: %s/n",		   (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");		sthread_init();		mutex = sthread_mutex_init();	sthread_mutex_lock(mutex);		if (sthread_create(thread_start, (void*)1, 1) == NULL) {		printf("sthread_create failed/n");		exit(1);	}		/* Wait until the other thread has at least started,	 * to give it a chance at getting through the mutex incorrectly. */	while (ran_thread == 0) {		sthread_yield();	}   sthread_dump();		/* The other thread has run, but shouldn't have been	 * able to affect counter (note that this is not a great test	 * for preemptive scheduler, since the other thread's sequence	 * is not atomic). */   	assert(counter == 0);		/* This should let the other thread run at some point. */	sthread_mutex_unlock(mutex);		/* Allow up to 100 checks in case the scheduler doesn't	 * decide to run the other thread for a really long time. */	checks = 100;	while (checks > 0) {		sthread_mutex_lock(mutex);		if (counter != 0) {			/* The other thread ran, got the lock,			 * and incrmented the counter: test passes. */			checks = -1;		} else {			checks--;		}		sthread_mutex_unlock(mutex);				/* Nudge the scheduler to run the other thread: */		sthread_yield();	}		if (checks == -1) {		printf("sthread_mutex passed/n");	} else {		printf("*** sthread_mutex failed/n");	}	sthread_mutex_free(mutex);	return 0;}

int main(int argc, char **argv) {  int arg = 1;  printf("Testing sthread_mutex_*, impl: %s/n",      (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");    sthread_init();  mon = sthread_monitor_init();    sthread_monitor_enter(mon);  if (sthread_create(thread_start, (void*)&arg, 1) == NULL) {    printf("sthread_create failed/n");    exit(1);  }  printf("thread principal vai bloquear-se/n");  sthread_monitor_wait(mon);  printf("thread principal desbloqueada/n");  i = 2;  printf("i=2/n");  sthread_monitor_exit(mon);  if (i==2) {    printf("/nSUCESSO!/n");  } else {    printf("/nteste falhado.../n");  }  return 1;}

async_job_t *async_job_new(void){   async_job_t *ajob = (async_job_t*)calloc(1, sizeof(*ajob));      if (!ajob)      return NULL;   ajob->lock   = slock_new();   if (!ajob->lock)      goto error;   ajob->sem = ssem_new(0);   if (!ajob->sem)      goto error;   ajob->thread = sthread_create(async_job_processor, (void*)ajob);   if (!ajob->thread)      goto error;   return ajob;error:   if (ajob->lock)      slock_free(ajob->lock);   ajob->lock = NULL;   if (ajob->sem)      ssem_free(ajob->sem);   if (ajob)      free((void*)ajob);   return NULL;}

static void rarch_main_data_thread_init(void){   if (!g_data_runloop.thread_inited)      return;   g_data_runloop.lock            = slock_new();   g_data_runloop.cond_lock       = slock_new();   g_data_runloop.cond            = scond_new();#ifdef HAVE_OVERLAY   rarch_main_data_overlay_thread_init();#endif   g_data_runloop.thread    = sthread_create(data_thread_loop, &g_data_runloop);   if (!g_data_runloop.thread)      goto error;   slock_lock(g_data_runloop.lock);   g_data_runloop.thread_inited   = true;   g_data_runloop.alive           = true;   g_data_runloop.thread_code     = THREAD_CODE_ALIVE;   slock_unlock(g_data_runloop.lock);   return;error:   data_runloop_thread_deinit();}

static bool thread_init(thread_video_t *thr, const video_info_t *info, const input_driver_t **input,      void **input_data){   thr->lock = slock_new();   thr->alpha_lock = slock_new();   thr->frame.lock = slock_new();   thr->cond_cmd = scond_new();   thr->cond_thread = scond_new();   thr->input = input;   thr->input_data = input_data;   thr->info = *info;   thr->alive = true;   thr->focus = true;   size_t max_size = info->input_scale * RARCH_SCALE_BASE;   max_size *= max_size;   max_size *= info->rgb32 ? sizeof(uint32_t) : sizeof(uint16_t);   thr->frame.buffer = (uint8_t*)malloc(max_size);   if (!thr->frame.buffer)      return false;   memset(thr->frame.buffer, 0x80, max_size);   thr->target_frame_time = (retro_time_t)roundf(1000000LL / g_settings.video.refresh_rate);   thr->last_time = rarch_get_time_usec();   thr->thread = sthread_create(thread_loop, thr);   if (!thr->thread)      return false;   thread_send_cmd(thr, CMD_INIT);   thread_wait_reply(thr, CMD_INIT);   return thr->cmd_data.b;}

static void test_fd(void){	int p[2];	sc_t sc;	char buf[1024];	int rc;	sthread_t st;	if (pipe(p) == -1)		err(1, "pipe()");	sc_init(&sc);	sc_fd_add(&sc, p[1], PROT_WRITE);	if (sthread_create(&st, &sc, fd_st, (void*) (long) p[1]))		err(1, "sthread_create()");	if (sthread_join(st, NULL))		err(1, "sthread_join()");	rc = read(p[0], buf, sizeof(buf) - 1);	if (rc <= 0)		err(1, "read()");	buf[rc] = 0;	if (strcmp(buf, "bye") != 0)		errx(1, "buf is %s", buf);	close(p[0]);	close(p[1]);}

/** * autosave_new: * @path            : path to autosave file * @data            : pointer to buffer * @size            : size of @data buffer * @interval        : interval at which saves should be performed. * * Create and initialize autosave object. * * Returns: pointer to new autosave_t object if successful, otherwise * NULL. **/autosave_t *autosave_new(const char *path, const void *data, size_t size,      unsigned interval){   autosave_t *handle = (autosave_t*)calloc(1, sizeof(*handle));   if (!handle)      return NULL;   handle->bufsize      = size;   handle->interval     = interval;   handle->path         = path;   handle->buffer       = malloc(size);   handle->retro_buffer = data;   if (!handle->buffer)   {      free(handle);      return NULL;   }   memcpy(handle->buffer, handle->retro_buffer, handle->bufsize);   handle->lock         = slock_new();   handle->cond_lock    = slock_new();   handle->cond         = scond_new();   handle->thread       = sthread_create(autosave_thread, handle);   return handle;}

static void rarch_main_data_thread_init(void){   data_runloop_t *runloop  = rarch_main_data_get_ptr();   if (!runloop)      return;   runloop->lock            = slock_new();   runloop->cond_lock       = slock_new();   runloop->cond            = scond_new();#ifdef HAVE_OVERLAY   rarch_main_data_overlay_thread_init();#endif   runloop->thread    = sthread_create(data_thread_loop, runloop);   if (!runloop->thread)      goto error;   slock_lock(runloop->lock);   runloop->thread_inited   = true;   runloop->alive           = true;   runloop->thread_code     = THREAD_CODE_ALIVE;   slock_unlock(runloop->lock);   return;error:   data_runloop_thread_deinit(runloop);}

static void test_syscall(void){	sc_t sc;	tag_t t;	char *buf;	sthread_t st;	t = tag_new();	buf = smalloc(t, 1024);	assert(buf);	sc_init(&sc);	sc_mem_add(&sc, t, PROT_READ | PROT_WRITE);	sc_sys_add(&sc, SYS_open);	sc_sys_add(&sc, SYS_close);	if (sthread_create(&st, &sc, sys_st, buf))		err(1, "sthread_create()");	if (sthread_join(st, NULL))		err(1, "sthread_join()");	if (strncmp(buf, "root", 4) != 0)		errx(1, "buf is %s", buf);}

static void *sunxi_gfx_init(const video_info_t *video,      const input_driver_t **input, void **input_data){   struct sunxi_video *_dispvars = (struct sunxi_video*)      calloc(1, sizeof(struct sunxi_video));   if (!_dispvars)      return NULL;   _dispvars->src_bytes_per_pixel = video->rgb32 ? 4 : 2;   _dispvars->sunxi_disp          = sunxi_disp_init("/dev/fb0");   /* Blank text console and disable cursor blinking. */   sunxi_blank_console(_dispvars);   _dispvars->pages = (struct sunxi_page*)calloc(NUMPAGES, sizeof (struct sunxi_page));   if (!_dispvars->pages)      goto error;   _dispvars->dst_pitch           = _dispvars->sunxi_disp->xres * _dispvars->sunxi_disp->bits_per_pixel / 8;   /* Considering 4 bytes per pixel since we will be in 32bpp on the CB/CB2/CT for hw scalers to work. */   _dispvars->dst_pixels_per_line = _dispvars->dst_pitch / 4;   _dispvars->pageflip_pending    = false;   _dispvars->nextPage            = &_dispvars->pages[0];   _dispvars->keep_vsync          = true;   _dispvars->menu_active         = false;   _dispvars->bytes_per_pixel     = video->rgb32 ? 4 : 2;   switch (_dispvars->bytes_per_pixel)   {      case 2:         pixman_blit = pixman_composite_src_0565_8888_asm_neon;         break;      case 4:         pixman_blit = pixman_composite_src_8888_8888_asm_neon;         break;      default:         goto error;   }   _dispvars->pending_mutex    = slock_new();   _dispvars->vsync_condition  = scond_new();   if (input && input_data)      *input = NULL;   /* Launching vsync thread */   _dispvars->vsync_thread     = sthread_create(sunxi_vsync_thread_func, _dispvars);   return _dispvars;error:   if (_dispvars)      free(_dispvars);   return NULL;}

void Test1(){    sthread_mutex_init(mut_ptr);    sthread_t thr1,thr2,thr3;    if (sthread_init() == -1){}    printf("Creating Thread 1/n");    if (sthread_create(&thr1, threadmain, (void *)1) == -1){}    sleep(2);    printf("Creating Thread 2/n");    if (sthread_create(&thr2, threadmain, (void *)2) == -1){}    sleep(2);    printf("Creating Thread 3/n");    if (sthread_create(&thr3, threadmain, (void *)3) == -1){}}

int main(int argc, char **argv){	sthread_t threads[NUM_TC];	sthread_t prodthr;	int i;	available_reqs = 0;		// initialize sthread lib		sthread_init();		//initialize filesystem	snfs_init(argc, argv);		   	// initialize SNFS layer       struct sockaddr_un servaddr;                		// initialize communications	srv_init_socket(&servaddr);				// initialize  monitor        mon = sthread_monitor_init();        	// create thread_consumer threads	for(i = 0; i < NUM_TC; i++) {		threads[i] = sthread_create(thread_consumer, (void*) NULL,1);		if (threads[i] == NULL) {			printf("Error while creating threads. Terminating.../n");			exit(-1);		}	}		// create producer thread	prodthr = sthread_create(thread_producer, (void*) NULL,1);			sthread_join(prodthr, (void**)NULL);	for(i = 0; i < NUM_TC; i++)		sthread_join(threads[i], (void **)NULL);	return 0;}

static bool dsound_start_thread(dsound_t *ds){   if (!ds->thread)   {      ds->thread_alive = true;      ds->thread = sthread_create(dsound_thread, ds);      if (!ds->thread)         return false;   }   return true;}

static void retro_task_threaded_init(void){   running_lock  = slock_new();   finished_lock = slock_new();   worker_cond   = scond_new();   slock_lock(running_lock);   worker_continue = true;   slock_unlock(running_lock);   worker_thread = sthread_create(threaded_worker, NULL);}

int main(int argc, char **argv){  int ii;  for(ii = 0; ii < NTHREADS; ii++){    sthread_create(&(threads[ii]), &go, ii);  }  for(ii = 0; ii < NTHREADS; ii++){    long ret = sthread_join(threads[ii]);    printf("Thread %d returned %ld/n", ii, ret);  }  printf("Main thread done./n");  return 0;}

int main(int argc, char *argv[]){  sthread_t thr1, thr2;  if (sthread_init() == -1)    fprintf(stderr, "%s: sthread_init: %s/n", argv[0], strerror(errno));  if (sthread_create(&thr1, threadmain, (void *)1) == -1)    fprintf(stderr, "%s: sthread_create: %s/n", argv[0], strerror(errno));  if (sthread_create(&thr2, threadmain, (void *)2) == -1)    fprintf(stderr, "%s: sthread_create: %s/n", argv[0], strerror(errno));  sleep(1);  sthread_wake(thr1);  sleep(1);  sthread_wake(thr2);  sleep(1);  sthread_wake(thr1);  sthread_wake(thr2);  sleep(1);  return 0;}

int main(int argc, char **argv) {    sthread_t thread = NULL;    int * res = (int *) malloc(sizeof(int));    printf("Testing sthread_mutex_*, impl: %s/n",           (sthread_get_impl() == STHREAD_PTHREAD_IMPL) ? "pthread" : "user");    sthread_init();    if ((thread = sthread_create(thread_start, (void *) NULL, 1)) == NULL) {        printf("sthread_create failed/n");        exit(1);    }    sthread_join(thread, (void**)&res);    printf("/nteste concluido: consultar dump*.tsv/n");    return 1;}

static void *launch_sthread(stcb_t cb, void *arg){	sc_t sc;	sthread_t st;	void *ret;	sc_init(&sc);	if (sthread_create(&st, &sc, cb, arg))		err(1, "sthread_create()");	if (sthread_join(st, &ret))		err(1, "sthread_join()");	return ret;}

static void btstack_set_poweron(bool on){   if (!btstack_try_load())      return;   if (on && !btstack_thread)      btstack_thread = sthread_create(btstack_thread_func, NULL);   else if (!on && btstack_thread && btstack_quit_source)   {#ifdef __APPLE__      CFRunLoopSourceSignal(btstack_quit_source);#endif      sthread_join(btstack_thread);      btstack_thread = NULL;   }}

CDIF_MT::CDIF_MT(CDAccess *cda) : disc_cdaccess(cda), CDReadThread(NULL), SBMutex(NULL), SBCond(NULL){   try   {      CDIF_Message msg;      RTS_Args s;      SBMutex            = slock_new();      SBCond             = scond_new();      UnrecoverableError = false;      s.cdif_ptr = this;      CDReadThread = sthread_create((void (*)(void*))ReadThreadStart_C, &s);      EmuThreadQueue.Read(&msg);   }   catch(...)   {      if(CDReadThread)      {         sthread_join((sthread_t*)CDReadThread);         CDReadThread = NULL;      }      if(SBMutex)      {         slock_free((slock_t*)SBMutex);         SBMutex = NULL;      }      if(SBCond)      {         scond_free((scond_t*)SBCond);         SBCond = NULL;      }      if(disc_cdaccess)      {         delete disc_cdaccess;         disc_cdaccess = NULL;      }      throw;   }}