Linux 异步网页程序,linux下实现程序异步执行

目标：main()函数调用数据采集函数，在main函数结束并返回后，数据采集函数仍然可以执行

尝试1：多线程 muliple threads

思想：使用pthread_create()函数在main函数内创建新线程，期望main函数的结束不会影响子线程，使其能长期执行下去

实验代码：

#include

#include

#include

using namespace std;

pthread_t id_thread_1,id_thread_2;

int data_common;

pthread_mutex_t lock_threads = PTHREAD_MUTEX_INITIALIZER;

void * add(void *arg)

{

for(int k = 0;k<20;k++)

{

usleep(200000);

pthread_mutex_lock(&lock_threads);

data_common+= 321;

cout<

pthread_mutex_unlock(&lock_threads);

}

return ((void *)0);

}

void * sub(void *arg)

{

for(int m=0;m<30;m++)

{

usleep(300000);

pthread_mutex_lock(&lock_threads);

data_common -= 91;

cout<

pthread_mutex_unlock(&lock_threads);

}

return ((void *)0);

}

int main(int argc,char **argv)

{

int err;

void *tret;

err = pthread_create(&id_thread_1,NULL,add,NULL);

if(err!=0)

{

cerr << "pthread_create(add) error !"<

exit(-1);

}

err = pthread_create(&id_thread_2,NULL,sub,NULL);

if(err!=0)

{

cerr << "pthread_create(add) error !"<

exit(-1);

}

err = pthread_join(id_thread_1,&tret);

if(err !=0)

{

cerr << "can not join with thread "<< id_thread_1 <

exit(-1);

}

err = pthread_join(id_thread_2,&tret);

if(err !=0)

{

cerr << "can not join with thread "<< id_thread_2 <

exit(-1);

}

return 0;

}结果：

1。如果主线程不等待子线程结束就直接返回，那么子线程当即死亡(仅仅指在终端看不到执行结果)

2。如果主线程等待子线程执行结束再返回，那么所有线程将同步结束

结论：使用线程的方法行不通，尝试1失败。

尝试2：使用软定时器＋信号

思想：使用软定时器，每隔一定时间，就产生一个指定的信号。而将需要定期执行的函数设置为该信号的处理函数。以此来实现函数的定期执行。

实验代码：

#include

#include

#include

#include

#include

#include

const char *prompt="时间已经过去了0.5秒钟\n";

unsigned int len;

void prompt_info(int signo)

{

printf(prompt);

//write(STDERR_FILENO,prompt,len);

}

void init_sigaction(void)

{

struct sigaction act;

act.sa_handler=prompt_info;//信号处理函数

act.sa_flags=0;

sigemptyset(&act.sa_mask);//用来将act.sa_mask信号集初始化并清空

sigaction(SIGALRM,&act,NULL);//查询活设置信号处理方式

}

void init_time()

{

struct itimerval value;

value.it_value.tv_sec=0;

value.it_value.tv_usec=500000;

value.it_interval=value.it_value;

setitimer(ITIMER_REAL,&value,NULL);

}

int main()

{

len=strlen(prompt);

init_sigaction();

init_time();

usleep(4000000);

return 0;

}

实验结果：函数执行完毕时软定时器自动失效。函数进入sleep状态后软定时器也失效。

结论：软定时器方法无效，失败。

尝试3：使用fork函数 创建新进程

思想：函数被调用时由父进程返回，子进程继续处理数据。

实验代码：

#include

#include

#include

#include

#include

using namespace std;

pid_t sub()

{

pid_t pd;

char *cmd;

pd = fork();

switch(pd)

{

case -1:

cout << "fork() error !"<

return 1;

case 0:

cout << "This is the child process ."<

goto label_child;

default:

cout << "My child process pid ="<

goto label_parent;

}

label_child:

cmd= new char[2];

memset(cmd,0,2*sizeof(char));

*cmd=0x0d;

cout <

usleep(1000);

for(int m =10;m<123456;m++)

{

printf("%8d",m);

fflush(stdout);

usleep(10000);

printf(cmd);

}

free(cmd);

return 0;

label_parent:

return pd;

}

int main()

{

pid_t p = sub();

cout << "Child is still executing ..."

"Press any key to kill the child."<

getc(stdin);

char *cmd = new char[100];

memset(cmd,0,100*sizeof(char));

sprintf(cmd,"kill %d",p);

system(cmd);

free(cmd);

cout << "Game over!"<

return 0;

}

实验结果：可以实现函数调用结束后继续执行的功能。

结论：成功

尝试4：使用定时器＋中断处理函数

实验代码：未做 ^_^

结果：应该比前几个都要好