进程树打印

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <dirent.h>
char default_path[1024]="/proc/";
int s=0;

typedef struct file_info{
    int pid;
    int ppid;
    char name[1024];
    int flag;
    int rec;
}info;
int my_getpid(char *str){
    int len=strlen(str);
    char num[10];
    int i,j,ret;
    if(strncmp(str,"pid",3)==0){
        for(i=0;i<len;i++)
            if(str[i]>='0'&&str[i]<='9')
                break;
        for(j=0;j<len-1;j++)
            num[j]=str[i+j];
        ret=atoi(num);
    }else{
        ret=0;
    }
    return ret;
}
int my_getppid(char *str){
    int len=strlen(str);
    char num[10];
    int i,j,ret;
    if(strncmp(str,"ppid",4)==0){
        for(i=0;i<len;i++)
            if(str[i]>='0'&&str[i]<='9')
                break;
        for(j=0;j<len-1;j++)
            num[j]=str[i+j];
        ret=atoi(num);
    }else{
        ret=0;
    }
    return ret;
}

int chile_exist(info *file,int count,int ppid){
    int i;
    for(i=0;i<count;i++){
        if(file[i].flag==0&&file[i].ppid==ppid)
            return 1;
    }
    return 0;
}

void print_pstree(info *file,int count,int ppid,int rec){
    int i,j,k;
    for(i=0;i<count;i++){
        if(file[i].flag==0&&file[i].ppid==ppid){
            file[i].rec=rec+1;
            file[i].flag=1;
            for(k=0;k<rec;k++)
                printf("     ");
            printf("%s\n",file[i].name );
            print_pstree(file,count,file[i].pid,file[i].rec);
        }
    }
}
int main()  
{  
    int i,j,k,total,s1,s2,count,t;
    char str[1024],dir[1024];
    struct dirent **namelist;
    strcpy(dir,default_path);
    total=scandir(dir,&namelist,0,alphasort);
    printf("path=%s,total=%d\n",dir,total );
    for(i=0;i<total;i++){
        strcpy(str,namelist[i]->d_name);
        if(str[0]>='0'&&str[0]<='9') count++;

    } 
    printf("进程数 :%d\n",count);
        info file[1024];
        i=0;t=0;
    while(i<total){
        FILE *fp;
        char path[1024],name[1024];
        int pid,ppid;
        strcpy(str,namelist[i]->d_name);
        strcpy(path,default_path);
        if(str[i]>='0'&&str[0]<='9'){
            strcat(path,str);
            strcat(path,"/status");
            fp=fopen(path,"r");
            while(!feof(fp)){
                fgets(str,1024,fp);
                if((s1=my_getpid(str))!=0) pid=s1;
                if((s2=my_getppid(str))!=0) ppid=s2;
                if(strncmp(str,"Name",4)==0){
                    for(j=4;j<strlen(str);j++){
                        if(str[j]>='a'&&str[j]<='z') break;
                    }
                    for(k=j;k<strlen(str);k++)
                        name[k-j]=str[k];
                    name[k-j-1]='\0';
                }
                file[t].pid=pid;
                file[t].ppid=ppid;
                strcpy(file[t].name,name);
            }
            fclose(fp);
            t++;
        }
        i++;
    }
    memset(&file->flag,0,count);
    memset(&file->rec,0,count);
    print_pstree(file,count,0,0);
    return 0;
} 

打印a,b,c

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <errno.h>  
#include <pthread.h>  

#define LP_TIMES    10  

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  

pthread_cond_t cond_AB = PTHREAD_COND_INITIALIZER;  
pthread_cond_t cond_BC = PTHREAD_COND_INITIALIZER;  
pthread_cond_t cond_CA = PTHREAD_COND_INITIALIZER;  

//标记  
int flag_AB,flag_BC,flag_CA;  

//标记检查的线程等待  
void th_condflag_wait(int *flag,pthread_cond_t *cond,pthread_mutex_t *mutex)  
{  
    (*flag) = 1;  
    pthread_cond_wait(cond,mutex);  
    (*flag) = 0;  
}  

//标记检查的线程通知  
void th_condflag_broadcast(int *flag,pthread_cond_t *cond,pthread_mutex_t *mutex)  
{  
    while(!(*flag))  
    {  
        pthread_mutex_unlock(mutex);  
        usleep(50);  
        pthread_mutex_lock(mutex);  
    }  
    pthread_cond_broadcast(cond);  
}  

void *th_fun_A(void *arg)  
{  
    int i = LP_TIMES;  
    while(i--)  
    {  
        pthread_mutex_lock(&mutex);  
        //A wait C  
        th_condflag_wait(&flag_CA,&cond_CA,&mutex);  

        printf("A%d: %lx\n",10-i,pthread_self());  

        //A cond B  
        th_condflag_broadcast(&flag_AB,&cond_AB,&mutex);  
        pthread_mutex_unlock(&mutex);  

        usleep(50);  
    }  
    //防止C线程最后一次等待A线程时死锁  
    flag_CA = 1;  
}  

void *th_fun_B(void *arg)  
{  
    int i = LP_TIMES;  
    while(i--)  
    {  
        pthread_mutex_lock(&mutex);  
        //B wait A  
        th_condflag_wait(&flag_AB,&cond_AB,&mutex);  

        printf("B%d: %lx\n",10-i,pthread_self());  

        //B cond C  
        th_condflag_broadcast(&flag_BC,&cond_BC,&mutex);  
        pthread_mutex_unlock(&mutex);  

        usleep(50);  
    }  
}  

void *th_fun_C(void *arg)  
{  
    int i = LP_TIMES;  
    while(i--)  
    {  
        pthread_mutex_lock(&mutex);  
        //C wait B  
        th_condflag_wait(&flag_BC,&cond_BC,&mutex);  

        printf("C%d: %lx\n",10-i,pthread_self());  

        //C cond A  
        th_condflag_broadcast(&flag_CA,&cond_CA,&mutex);  
        pthread_mutex_unlock(&mutex);  
        usleep(50);  
    }  
}  

int main(void)  
{  
    printf("main: %lx\n",pthread_self());  

    //保存3个线程的处理函数  
    void *(*th_funs[])(void *) =   
    {  
        th_fun_A,  
        th_fun_B,  
        th_fun_C  
    };  

    int th_count = sizeof(th_funs)/sizeof(th_funs[0]);  

    pthread_t th[th_count];  
    int i;  
    for(i = 0;i < th_count;i++)  
    {  
        //通过线程函数数组记录的函数来创建线程  
        if(pthread_create(th+i,NULL,th_funs[i],(void *)i) < 0)  
        {  
            fprintf(stderr,"th_create: %s\n",  
                    strerror(errno));  
            exit(1);  
        }  
        printf("th[%d]: %lx\n",i,th[i]);  
    }  

    //起始给A线程发出通知，防止A和C死锁  
    pthread_mutex_lock(&mutex);  
    th_condflag_broadcast(&flag_CA,&cond_CA,&mutex);  
    pthread_mutex_unlock(&mutex);  

    //回收线程  
    for(i = 0;i < th_count;i++)  
    {  
        pthread_join(th[i],NULL);  
        printf("i: %d finished!\n",i);  
    }  

    return 0;  
}