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

static void restart_thread(pthread_t *waiter, int cancelable){  int status;  /* Destroy the condition variable */  printf("restart_thread: Destroying cond/n");  status = pthread_cond_destroy(&cond);  if (status != 0)    {      printf("restart_thread: ERROR pthread_cond_destroy failed, status=%d/n", status);    }  /* Destroy the mutex */  printf("restart_thread: Destroying mutex/n");  status = pthread_cond_destroy(&cond);  if (status != 0)    {      printf("restart_thread: ERROR pthread_mutex_destroy failed, status=%d/n", status);    }  /* Then restart the thread */  printf("restart_thread: Re-starting thread/n");  start_thread(waiter, cancelable);}

void main(void){    startup_board();    start_thread(&service_thread, service, 0, stack, sizeof(stack));    start_cdc_service();    set_cdc_timeout(10);    while (1)    {        yield_thread((condition_t)has_cdc_connection, 0);        debug("connected/n");        while (has_cdc_connection())        {            static u8_t buffer[1024];            const u32_t count = read_cdc_data(buffer, sizeof(buffer));            if (count)            {                write_cdc_data(buffer, count);                debug("%m/n", buffer, count);            }        }        debug("disconnected/n");    }}

    recoder(const char* local_ip_1, const char* local_port_1,            const char* remote_ip_1, const char* remote_port_1,            const char* local_ip_2, const char* local_port_2,            const char* remote_ip_2, const char* remote_port_2)    {        udp1 = new udp_recoder_stack({ {"udp_socket::local_ip", local_ip_1},                                       {"udp_socket::local_port", local_port_1},                                       {"udp_socket::remote_ip", remote_ip_1},                                       {"udp_socket::remote_port", remote_port_1},                                       {"kodo::tx_redundancy", 1.167} });        udp2 = new udp_recoder_stack({ {"udp_socket::local_ip", local_ip_2},                                       {"udp_socket::local_port", local_port_2},                                       {"udp_socket::remote_ip", remote_ip_2},                                       {"udp_socket::remote_port", remote_port_2},                                       {"kodo::tx_redundancy", 1.167} });        udp1->connect_signal_fw(boost::bind(&udp_recoder_stack::write_pkt, udp2, _1));        udp2->connect_signal_fw(boost::bind(&udp_recoder_stack::write_pkt, udp1, _1));        start_thread();#ifdef VERBOSE        printf("%s/n", "recoder class created");#endif    }

 void Thread::fork(STATE) {   if(int error = start_thread(state, Thread::run)) {     char buf[RBX_STRERROR_BUFSIZE];     char* err = RBX_STRERROR(error, buf, RBX_STRERROR_BUFSIZE);     Exception::raise_thread_error(state, err);   } }

  SignalHandler::SignalHandler(STATE, Configuration& config)    : AuxiliaryThread()    , shared_(state->shared())    , target_(state->vm())    , self_(NULL)    , queued_signals_(0)    , paused_(false)    , exit_(false)    , thread_(state)  {    signal_handler_ = this;    shared_.auxiliary_threads()->register_thread(this);    shared_.set_signal_handler(this);    for(int i = 0; i < NSIG; i++) {      pending_signals_[i] = 0;    }    worker_lock_.init();    worker_cond_.init();    pause_cond_.init();    setup_default_handlers(config.report_path.value);    start_thread(state);  }

void open_console(){	safe_pipe(&control_read,&control_write);	safe_pipe(&size_read,&size_write);	safe_pipe(&stdin_read,&stdin_write);	start_thread(stdin_loop,NULL);}

void test_thread_move_from_rvalue_using_explicit_move(){    //boost::thread x(boost::move(start_thread()));    boost::thread x=start_thread();    BOOST_CHECK(x.get_id()!=boost::thread::id());    x.join();}

int pigpio_start(char *addrStr, char *portStr){   if (!gPigStarted)   {      gPigCommand = pigpioOpenSocket(addrStr, portStr);      if (gPigCommand >= 0)      {         gPigNotify = pigpioOpenSocket(addrStr, portStr);         if (gPigNotify >= 0)         {            gPigHandle = pigpio_command(gPigNotify, PI_CMD_NOIB, 0, 0, 1);            if (gPigHandle < 0) return pigif_bad_noib;            else            {               pthNotify = start_thread(pthNotifyThread, 0);               if (pthNotify)               {                  gPigStarted = 1;                  return 0;               }               else return pigif_notify_failed;            }         }         else return gPigNotify;      }      else return gPigCommand;   }   return 0;}

int main(int argc, const char *argv[]){   printf("/n/n");   // Listen to SIGINT signals (program termination)   signal(SIGINT, signal_handler);   // Tell linux not to use the user leds in the board.   take_over_leds();   // Load device tree overlay to enable PRU hardware.   load_device_tree_overlay();   // Load and run binary into pru0   init_pru_program();   open_sound_file();   start_thread();   /* while(!finish){ */   sleep(5);   /* } */   prussdrv_pru_disable(PRU_NUM);   prussdrv_exit ();   stop_thread();   close_sound_file();   return 0;}

static void cmd_poll(void){	printf("#####################################/n");	printf("##     NFC demo through Neardal    ##/n");	printf("#####################################/n");	if (create_loop(&main_loop) != NEARDAL_SUCCESS) return;	do	{		main_loop_state = wait;		/* Start discovery Loop */		if (start_discovery(NEARD_ADP_MODE_DUAL) != NEARDAL_SUCCESS) return;			printf("---- Waiting for a Tag/Device");		/* Start a thread to get keystroke */		if (start_thread(&wait_for_keystroke) != NEARDAL_SUCCESS) return;		/* Wait for tag/device lost to restart the discovery or for keystroke to leave */		g_timeout_add (100 , wait_lost , main_loop);		g_main_loop_run(main_loop);	/* loop until keystroke */	} while (main_loop_state != keystroke);	g_main_loop_unref(main_loop);	neardal_stop_poll(AdpName);	printf("Leaving .../n");}

static uae_u32 scsidev_open (void){    uaecptr tmp1 = m68k_areg (regs, 1); /* IOReq */    uae_u32 unit = m68k_dreg (regs, 0);    struct scsidevdata *sdd;#ifdef DEBUGME    printf("scsidev_open(0x%x, %d)/n", tmp1, unit);#endif    /* Check unit number */    if ((sdd = get_scsidev_data (unit)) &&	start_thread (sdd)) {		opencount++;		put_word (m68k_areg (regs, 6)+32, get_word (m68k_areg (regs, 6)+32) + 1);		put_long (tmp1 + 24, unit); /* io_Unit */		put_byte (tmp1 + 31, 0); /* io_Error */		put_byte (tmp1 + 8, 7); /* ln_type = NT_REPLYMSG */		return 0;    }    put_long (tmp1 + 20, (uae_u32)-1);    put_byte (tmp1 + 31, (uae_u8)-1);    return (uae_u32)-1;}

int main(){       initports();    printf("/nCreating a client/n");    clientid++;    start_thread(client);    printf("/nCreating a client/n");    clientid++;    start_thread(client1);   printf("/nCreating a server/n");    start_thread(server);    printf("/n/n");    run();    while (1) 	{ sleep(1);}}   

void simple_test(func_args* args){    THREAD_TYPE serverThread;    func_args svrArgs;    char *svrArgv[NUMARGS];    char argc0s[32];    char argc1s[32];    char argc2s[32];    func_args cliArgs;    char *cliArgv[NUMARGS];    char argc0c[32];    char argc1c[32];    char argc2c[32];    svrArgv[0] = argc0s;    svrArgv[1] = argc1s;    svrArgv[2] = argc2s;    cliArgv[0] = argc0c;    cliArgv[1] = argc1c;    cliArgv[2] = argc2c;    svrArgs.argc = 1;    svrArgs.argv = svrArgv;    svrArgs.return_code = 0;    cliArgs.argc = 1;    cliArgs.argv = cliArgv;    cliArgs.return_code = 0;       strcpy(svrArgs.argv[0], "SimpleServer");    #if !defined(USE_WINDOWS_API) && !defined(CYASSL_SNIFFER)        svrArgs.argc = NUMARGS;        strcpy(svrArgs.argv[1], "-p");        strcpy(svrArgs.argv[2], "0");    #endif    /* Set the last arg later, when it is known. */    args->return_code = 0;    svrArgs.signal = args->signal;    start_thread(server_test, &svrArgs, &serverThread);    wait_tcp_ready(&svrArgs);       /* Setting the actual port number. */    strcpy(cliArgs.argv[0], "SimpleClient");    #ifndef USE_WINDOWS_API        cliArgs.argc = NUMARGS;        strcpy(cliArgs.argv[1], "-p");        snprintf(cliArgs.argv[2], sizeof(argc2c), "%d", svrArgs.signal->port);    #endif    client_test(&cliArgs);    if (cliArgs.return_code != 0) {        args->return_code = cliArgs.return_code;        return;    }    join_thread(serverThread);    if (svrArgs.return_code != 0) args->return_code = svrArgs.return_code;}

void lcd_thread_start(void){	if(cfg.enablelcd)	{		running = 1;		start_thread((void *) &refresh_lcd_file, "LCD");	}}

void lcd_thread_start(void){	if(cfg.enablelcd)	{		running = 1;		start_thread("LCD", (void *) &refresh_lcd_file, NULL, NULL, 1, 1);	}}

voidthread_pool_start(thread_pool_t *tp){    ASSERT(tp, "start thread from empty thread pool");	int i = 0;	for (; i < tp->thread_count; ++i)		start_thread(tp->threads + i);}

static void schedule_new_thread(struct k_thread *thread, s32_t delay){#ifdef CONFIG_SYS_CLOCK_EXISTS	if (delay == 0) {		start_thread(thread);	} else {		s32_t ticks = _TICK_ALIGN + _ms_to_ticks(delay);		int key = irq_lock();		_add_thread_timeout(thread, NULL, ticks);		irq_unlock(key);	}#else	ARG_UNUSED(delay);	start_thread(thread);#endif}

static HANDLEw32_create_thread(DWORD stack_size, w32_thread_start_func func, void *val){    return start_thread(0, stack_size, func, val, CREATE_SUSPENDED#ifdef _WIN32_WCE        |STACK_SIZE_PARAM_IS_A_RESERVATION#endif        ,0);}

int main(){      p[0].in=0; p[0].out=0;   p[20].in=0; p[20].out=0;   p[99].in=0; p[99].out=0;    init_port();	printf("/n/t/t/tCreating a client1");    start_thread(client1);	printf("/n/t/t/tCreating a client2");    start_thread(client2);	printf("/n/t/t/tCreating a client3");    start_thread(client3);	printf("/n/t/t/tCreating a server");	printf("/n/t/t/t*******************/n");    start_thread(server);	run();    while (1) sleep(1);}   

int main(int argc, char* argv[]) {    start_thread();        //wait 10 seconds before exiting main    std::this_thread::sleep_for(std::chrono::seconds(10));    std::cout << "Exit main!" << std::endl;        return 0;}

        WriterThread(Pipe<SendableThing *> *fpipe, int in_fd) {            assert(fpipe != NULL);            assert(in_fd >= 0);            _fpipe = fpipe;            _in_fd = in_fd;            start_thread( );        }

/* Main function to test */int main(){ Q = InitQ(Q); start_thread(function1);// start_thread(function2);// start_thread(function3);// start_thread(function4); run();}

void MainWindow::createcapthread(){    capture = new Capture_thread;    connect(capture, SIGNAL(start_cap()),            this, SLOT(start_thread()));    connect(capture, SIGNAL(show_listdata(const ListData, QString)),            this, SLOT(update_show(const ListData, QString)), Qt::QueuedConnection);}

SvgSubprocessCharacterGenerator::SvgSubprocessCharacterGenerator(    const char *cmd, unsigned int dirty_level) : CharacterGenerator(1), _dirty_level(dirty_level) {    _cmd = strdup(cmd);    send_fd = -1;    recv_fd = -1;    start_thread( );}

void factor_vm::open_console() {  FACTOR_ASSERT(!stdin_thread_initialized_p);  safe_pipe(&control_read, &control_write);  safe_pipe(&size_read, &size_write);  safe_pipe(&stdin_read, &stdin_write);  stdin_thread = start_thread(stdin_loop, NULL);  stdin_thread_initialized_p = true;  pthread_mutex_init(&stdin_mutex, NULL);}

  void SignalHandler::after_fork_child(STATE) {    worker_lock_.init();    worker_cond_.init();    pause_cond_.init();    VM::discard(state, self_);    self_ = NULL;    start_thread(state);  }

K init(K x){    dumb_socketpair(sockets, 0);    sd1(sockets[1], recieve_data);        FEED_STATE = FF_CONTINUE_FEED;    start_thread();    return (K) 0;}

    void Metrics::start(STATE) {      vm_ = NULL;      thread_exit_ = false;      timer_ = new timer::Timer;      metrics_collection_.init();      metrics_history_.init();      start_thread(state);    }