线程编程之浅尝辄止1

小灰灰 2022-08-06 14:16 135阅读 0赞

学习线程是一件很好玩的是，它不像进程那样复杂而且很好用。下面是我写的一段代码，附有一定的解释和说明，以及一些思考，看懂了我这段代码和注释，那么线程编程就入门了，合适新手研究。不对的地方请多多指教啊。

代码由A、B、C、D、E、EE六个线程，其功能有，主线程传参（结构体、整形、字符串）、子线程返回参数的两种方法、创建双层线程（父子孙，不建议这样做）以及他们之间的参数传递与计算等，好好研究吧。

#include <stdio.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    struct menber
    {
        int a;
        char *s;
    };
    
    struct fo
    {
    	int a,b,c,d;
    }foo={1,2,3,4};
    void printfoo(const char *s,const struct fo *fp)
    {
    	printf("%s",s);
    	printf("foo.a=%d\n",fp->a);
    	printf("foo.b=%d\n",fp->b);
    	printf("foo.c=%d\n",fp->c);
    	printf("foo.d=%d\n",fp->d);
    }
    void *thr_D(void *arg)//子线程传给父线程一个结构体
    {
    	printfoo("我是线程D:\n",&foo);
    	pthread_exit((void *)&foo);//这个地方的&引用一定不要丢，丢了，编译通过但运行出现段错误
    
    }
    
    void *thr_C(void *arg)//传递字符串
    {
       char *name=(int *)arg; //-Wall编译时出现警告：从不兼容的指针尅想初始化
    //   sleep(1);
       printf("我是线程C,ID = %u，得到的字符串name=%s\n",(unsigned int)pthread_self(),name);
       return (void *)0;
    }
    void *thr_B(void *arg)//传递整形
    {
        int *m =(int *)arg; 
        printf("我是线程B,ID = %u，得到的整形m=%u\n",(unsigned int)pthread_self(),*m);
        return (void *)0;
    }
    void *thr_A(void *arg)//传递结构体
    {
        struct menber *temp;
    	temp=(struct menber *)arg;
        printf("我是线程A,ID = %u，我从进程得到strut：",(unsigned int)pthread_self());
        printf("menber->a = %d ; ",temp->a);
        printf("menber->s = %s  \n",temp->s);
        return (void *)0;
    }
    void *thr_EE(void *arg)//父子间互相通信
    {
        int c;
        int *b=(void *)arg;
    	printf("我是sun线程,");
    	printf("请输入一个数：");
    	scanf("%d",&c);//在%d后面不能加\n,不然执行到这句后，就不在执行了    
        c=c*(*b);		 
    	printf("  经过计算*参数值得到c = %d\n",c);
        return (void *)c;
    //这是线程与进程之间互相传至的程序，在线程中可以使用return 和
    //pthread_exit,返回值到进程，效果是一样
    }
    
    void *thr_E(void *arg)//父子间互相通信
    {
    	pthread_t EE;
        int *aa=(int *)arg;
    	int x =1;
    	int *atr = &x;
    	int *y;
    	printf("我是zi线程,我得到了父线程的参数：%d\n",*aa);
    	x=x+ (*aa);
    	printf("  经过我的计算加1得出：%d\n",x);
    	pthread_create(&EE, NULL, thr_EE,(void *)atr);
    	pthread_join(EE,(void *)&y);
    	printf("zi经过孙线程计算得到：%d\n",y);
    	pthread_exit((void *)y);
    }
    
    int main(int argc,char *argv[])
    {
        pthread_t A,B,C,D,E;
    	int a,*count;
    	int *atr=&a;
    
    	
    	int error;
    	struct menber *b;
    	struct fo *fp;
    	int m =1;
        int *attr=&m;
    	char *name ="My name is BHW!";
    	b=(struct menber *)malloc( sizeof(struct menber) );
        b->a = 4;
        b->s = "我是hubbybob";
    //3个思考题：
    //1：3个join分别在creat函数下，会是什么结果？
    //2:把3个join放到所有creat后面，回事什么结果？
    //3：把3个join去掉，回事什么结果？
        error = pthread_create(&C, NULL, thr_C, (void *)name);
        error = pthread_create(&B, NULL, thr_B, (void *)attr);//如果传入的参数为多个，必须以结构体的形式传入
        error = pthread_create(&A, NULL, thr_A, (void *)b);
        //pthread_join(C, NULL);
      //  pthread_join(B, NULL);
    //    pthread_join(A, NULL);
    //答案：
    //1：打印的结果是A-B-C的顺序，但是其线程的ID是一样的
    //2：不管ABC的join的顺序如何，打印的结果只与creat的顺序，先执行最后一个，而且线程ID不一样，增大,为什么？
    //3：去掉join后打印的顺序为CBA，打印顺序与creat的顺序有关，先执行最后一个，且线程ID不一样，增大，为什么？
    //线程创建时不保证哪个线程先运行,其所有的现象调试都可用sleep，来调试，效果是很明显的，大家可以试一试
    //并且可以通过sleep来调节他们的占空比
        sleep(1);
        printf("下面是由线程传给进程的参数：\n");
        error = pthread_create(&D, NULL, thr_D, NULL);
        pthread_join(D,(void *)&fp );
    //这里的&引用符号不能少，少了后，编译通过，但运行发生段错误
    //放生段错误，修改正确之后，再次编译会打印这样一条消息
    //"You have new mail in /var/spool/mail/root"这是怎么回事呢？
    	sleep(1);
    	printfoo("我是D传回的：\n",fp);
        sleep(1);
    	printf("下面在线程中创建一个线程,但是不推荐使用：\n");
    //这是个很简单的多线程测试程序，在主线程中创建线程E ，在E 中创建EE ,
    //其功能是实现 count=(x+1)*y,x有主线程输入，y有孙线程输入
    //但是这是比较麻烦的，因为猪线程传值给E，E再传给EE，返回时EE返回给E，E再返回给主线程，
    //有没有办法直接由EE返回值给主线程？？？
         printf("我是父线程,请输入主参数a:");
    	 scanf("%d",&a); 
    	 error = pthread_create(&E, NULL, thr_E,(void *)atr);
    	 pthread_join(E,(void *)&count);
         printf("  经过zi与孙的计算得到count=%d\n",count);//-Wall选项编译时出现警告：%d为int，而参数为int *
    	 sleep(2);
    	return 0;
    }

这段代码的结果：

![SouthEast][]  
另一段代码的研究：其结果就不附图了，感兴趣的话，可以用sleep函数来控制，亲自体验一下。

//这是一个很有意思的程序，其输出的顺序是可以改变的：
    //1.当加上pthread_join()这个函数时，其顺序是先执行线程的内容，进程阻塞赛直至线程结束，但也与此函数的位置有关
    //2.当不加pthread_join()这个函数时，其顺序可由sleep()函数控制
    //3.当进程中的sleep去掉后则只能看到进程的内容被打印，是因为没有阻塞时，直接执行了return，结束了进程
    //4.sleep可以控制线程与进程的占空比
    
    #include <pthread.h>
    #include <unistd.h>
    #include <stdio.h>
    void *thread(void *str)
    {
        int i;
        for (i = 0; i < 6; ++i)
        {
           sleep(3);
            printf( "This in the thread : %d\n" , i );
        }
        return NULL;
    }
    
    int main()
    {
        pthread_t pth;
        int i;
        int ret = pthread_create(&pth, NULL, thread, (void *)(i));
        
       // pthread_join(pth, NULL);
        printf("123\n");
        for (i = 0; i < 4; ++i)
        {
            sleep(1);
            printf( "This in the main : %d\n" , i );
        }
        pthread_join(pth, NULL);
        return 0;
    }

[SouthEast]: /images/20220806/c1c6ae902c8e4377bd21ce0e89d6f0da.png