三个进程能够有多个线程

线程间的排挤:

线程的互斥函数有:互斥函数的开端化pthread_mutex_init(),互斥函数的锁定函数pthread_mutex_lock(),互斥函数的预锁定函数pthread_mutex_trylock(),互斥函数的解锁函数pthread_mutex_unlock(),互斥函数的销毁函数pthread_mutex_destroy()

 

废话不多说,上代码:

#include <stdio.h>

#include <pthread.h>

 #include <unistd.h>

#define MUXNUMBER 10

pthread_mutex_t test_mutex;

int testi = 0;

int testis[10 * 1000];

int count=0;

 

void testfun(void)

{

testis[testi] = testi * 2;

usleep(1000);

testi++;

}

 

void thread_func()

{

    int m_count=0;

   while(m_count<1000)

   {

       pthread_mutex_lock(&test_mutex);

       testfun();

       pthread_mutex_unlock(&test_mutex);

       m_count++;

       //sleep(1);

   }

}

 

int main()

{

    pthread_t t[10];

    pthread_mutex_init(&test_mutex,NULL);

    int i;

    for(i=0;i<MUXNUMBER;i++)

    {

        if(pthread_create(&t[i],NULL,(void*)thread_func,NULL) ==
-1)

        {

            printf(“create  Thread error !\n”);

            exit(1);

        }

        //sleep(1);

    }

 

    for(i=0;i<MUXNUMBER;i++)

    {

         pthread_join(t[i],NULL);

        //sleep(1);

    }

 

    pthread_mutex_destroy(&test_mutex);

    for(i=0;i<10000;i++)

    {

        if(testis[i]!=i*2)

        {

            printf(“第%d个数据出错!:%d\n”,i,testis[i]);

        }

 

    }

    return 0;

}

简单说下程序作用:程序创建十三个线程,每一种线程都调用testfun,通过互斥锁保险数据的符合规律。

代码相比容易,仅仅只是为了让读者强化上面前看的部分概念性的事物。

42.  

Linux下的十二线程编制程序须求注意的是程序必要包蕴头文件pthread.h,在扭转可执行文件的时候须求链接库libpthread.a大概libpthread.so。

39.   int main()

线程创造函数:

pthread_create(pthread_t *thread, pthread_attr_t * attr, void
*(*start_routine)(void *),void *arg);

参数表明:

Thread 标示2个线程,它是1个pthread_t类型的变量(unsigned long int)

attr 用于安装线程的天性,私下认可是null

start_routine当线程分配财富成功后,线程中所运维的单元,通俗的说正是您本身写的多个函数

Arg线程函数运营时传出的三个参数,一般能够用那个流传的参数去决定线程截至

函数重返值:

开创成功再次来到0,成立失利再次回到非0值,常见错误重返代码为EAGAIN何EINVAL,EGAIN标示系统中线程的数额达到上限,错误代码EINVAL表示线程的性质违法。

只顾:线程创立城成功后,新成立的线程根据参数3和参数4规定一个运行函数,原来的线程在线程创造函数重临后延续运营下一行代码。

 

 

线程甘休函数:pthread_join()和pthread_exit()

pthread_join()用来等待2个线程运维甘休。那些函数是闭塞函数,平素被等候的线程停止结束,函数才回来并且收回被守候线程的能源。函数的原型为:

Extern int pthread_join_P((pthread_t _th,void
**__thread_return));

_th:线程的标示符,也等于线程创设成功的值,在开头的说正是pthread_create函数运维成功后的第③个参数

__thread_return:再次来到值,它是一个指针用来存贮被等候线程的再次回到值。

 

线程函数的收尾格局有三种:一种是线程函数运营停止,不用回去结果;另一种正是透过函数pthread_exit()来促成,将结果传到。

函数原型是:

Extern void pthread_exit_P((void*_retval))

参数是函数的重返值,这么些值能够被pthread_join函数捕获,通过__thread_return参数获得此值。

 

说道线程的成立还有一些不能够不要提及,那正是线程的属性。一般在我们创设线程的时候设置attr属性的时候都以选拔null,那么些是暗中认可参数。不过在诸多时候必要调动线程的习性,尤其是线程优先级。

线程的性质结构为:pthread_attr_t,在头文件<pthreadtype.h>中定义

typedef struct

{

       int                              detachstate;   线程的停止情状

       int                              schedpolicy;  线程调度策略(优先级)

       struct sched_param           schedparam;  线程的调度参数

       int                              inheritsched;  线程的继承性

       int                               scope;       线程的成效域

       size_t                          guardsize;   线程栈末尾的警示缓冲区大小

       int                               stackaddr_set;  运行栈

       void *                         stackaddr;   线程栈的职责

       size_t                          stacksize;    线程栈的尺寸

}pthread_attr_t;

要注意的是线程的性质值不可能直接设置,必供给用先关的函数进行操作。线程属性的起初化函数pthread_attr_init(),那些函数必须在pthread_create()函数此前调用。

12.       {

12.         i++;

21.         

1.    #include<pthread.h>

34.         sem_post(&sem);

10.  

24.        sleep(1);

7.    {

32.           printf(“This is thread2:%d\n”,i);

 

32.        

28.   void thread2()

34.   pthread_create(&t2,NULL,(void *)thread2,NULL);

31.           sem_wait(&sem2);

 图片 1

18.           {

28.  

13.         sleep(1);

51.   pthread_join(t1,NULL);

23.   }

31.           sem_wait(&sem);

21.          i++;

start_routine:线程函数的原初地址

 

1.    #include<pthread.h>

28.  

•sem_post也等于V操作,它将信号量的值加一同时发出信号唤醒等待的进度。

30.       {  

7.    int i=0;

26.   void thread2()

8.        

34.         sem_post(&sem1);

函数传入值retval:pthread_exit()调用者线程的重返值,可由别的函数如pthread_join
来搜寻获取

This is thread1:4

44.   pthread_join(t2,NULL);

12.   {

2.    #include<stdio.h>

函数重返值  成功:0  出错:-1

1.线程概述

2.线程1和线程2或然对共享变量i的同时进行读取,假如供给每一回唯有3个线程读取i,成为互斥

http://www.bkjia.com/Linuxjc/556556.htmlwww.bkjia.comtruehttp://www.bkjia.com/Linuxjc/556556.htmlTechArticleLinux多线程 1.线程概述
线程是三个进度内的着力调度单位,也得以称之为轻量级进度。线程是在共享内部存储器空间中出现的多道执行路径,它们共…

10.       int ret;

19.         sleep(3);/*线程1蛰伏3s,以便观看线程2在输出3s后才会执行*/

51.   pthread_join(t2,NULL);

25.       }

46.   }

7.   

40.   {

26.           {

6.   

17.           printf(“This is thread1:%d\n”,i);

39.   /*创设线程*/

20.           printf(“This is thread1:%d\n”,i);

55.   }

13.        if(i>3)

27.   }

29.       while(1)

39.   return 0;

36.           pthread_mutex_lock(&mutex);

2.    #include<stdio.h>

13.       

53.    

55.   return 0;

 

37.   }

27.   {

23.   }

16.        

函数原型void pthread_exit(void *retval)

8.    sem_t sem1,sem2;

40.   {

16.             sem_wait(&sem1);

函数原型int pthread_create ((pthread_t *thread, pthread_attr_t
*attr,

50.    

 互斥锁的操作首要回顾以下几个步骤。

This is thread1:7

•sem_destroy用于删除信号量

<1>互斥锁

47.   pthread_mutex_init(&mutex,NULL);

30.       while(1)

  所需头文件#include <pthread.h>

53.    

43.    

9.   

11.           printf(“This is thread1:%d\n”,i);

41.        sleep(1);

41.   pthread_create(&t2,NULL,(void *)thread2,NULL);

15.   }

12.   {

  所需头文件#include <pthread.h>

35.         sleep(1);

4.   

19.   {

13.       

38.  

 

1.    #include<pthread.h>

15.        i++;

18.         i++;

48.   pthread_create(&t1,NULL,(void *)thread1,NULL);

是有七个线程序控制制表及仓库寄存器,但却共享3个用户地址空间。

37.           printf(“This is thread2:%d\n”,i);

17.        if(ret!=EBUSY)

9.    {

5.    /*线程1*/

33.         i++;

44.  

27.   {

24.  

2.    #include<stdio.h>

51.   pthread_join(t1,NULL);

函数重回值 成功:0 出错:-1

32.           printf(“This is thread2:%d\n”,i);

41.   pthread_t t1,t2;

49.   pthread_create(&t2,NULL,(void *)thread2,NULL);

50.    

33.   }

41.   pthread_t t1,t2;

11.   void thread1()

33.         i++;

2.    #include<stdio.h>

18.   void thread2()

13.           

47.   pthread_create(&t1,NULL,(void *)thread1,NULL);

14.           pthread_exit(0);

线程是一个历程内的基本调度单位,也得以称为轻量级进度。线程是在共享内部存款和储蓄器空间中冒出的多道执行路径,它们共享1个经过的财富,如文件讲述和信号处理。由此,大大减弱了上下文切换的支出。贰个进程可以有多少个线程,也就

54.   return 0;

38.          i++;

18.   }

8.    sem_t sem;

54.   }

22.     }

33.   pthread_create(&t1,NULL,(void *)thread1,NULL);

1.线程2的施行并非必须在线程1事后,假使须要线程2必须在线程1从此执行,称为同步

17.  

26.     }

 所需头文件#include <pthread.h>

 

29.           pthread_exit(0);

未开始展览联合处理的四个线程

3.    #include<errno.h>

 

42.   /*等待线程退出*/

17.       }

等候线程退出并释放能源pthread_join()

23.           printf(“This is thread2:%d\n”,i);

19.           pthread_mutex_lock(&mutex);/*上锁*/

12.        printf(“thread1:%d\n”,i);

31.   pthread_t t1,t2;

代码

15.        ret=pthread_mutex_trylock(&mutex);/*看清上锁*/

 

6.    void thread1()

26.   void thread2()

37.   pthread_t t1,t2;

8.    void thread1()

37.   pthread_join(t2,NULL);

23.       int i=0;

25.  

 

21.       while(1)

42.       }

24.  

34.        if(ret!=EBUSY)

6.   

27.        printf(“thread2:%d\n”,i);

36.   pthread_join(t1,NULL);

30.       {  

4.   

9.   

20.         sem_post(&sem);

函数字传送入值

10.       {  

3.    #include<errno.h>

7.    {

14.     }

• 互斥锁上锁:pthread_mutex_lock

52.    

19.  

23.        }

50.   pthread_join(t1,NULL);

29.   {int ret;

 

可以见见:

4.    #include <semaphore.h>

54.   pthread_mutex_destroy(&mutex);

7.    int i=0;

32.  

43.   pthread_join(t1,NULL);

46.   sem_init(&sem2,0,0);

1.    #include<pthread.h>

36.     }

信号量的运用

31.        sleep(1);

This is thread1:0

47.  

16.        sleep(1);

20.         sem_post(&sem2);

18.         i++;

39.   int main()

24.       

3.    #include<errno.h>

22.   {

17.           printf(“This is thread1:%d\n”,i);

 

2.    #include<stdio.h>

35.           {

42.  

52.   pthread_join(t2,NULL);

6.    void thread1()

16.  

25.         sleep(1);

10.  

Linux多线程

2.线程达成

11.           {

This is thread2:2

34.  

25.  

28.  

33.        ret=pthread_mutex_trylock(&mutex);

45.   return 0;

32.       }

38.  

46.   pthread_t t1,t2;

26.   }

3.    #include<errno.h>

10.           while(1)

14.       while(1)

14.        

21.         

5.    int i=0;/*共享变量*/

48.   pthread_create(&t1,NULL,(void *)thread1,NULL);

21.   void thread2()

45.   {

35.    

45.   sem_init(&sem,0,1);/*初步化信号量sem*/

This is thread1:3

44.   int main()

25.           while(1)

22.     }

……

24.         i++;

线程退出pthread_exit();

• 消除互斥锁:pthread_mutex_destroy

46.  

22.         pthread_mutex_unlock(&mutex);/*解锁*/

推行结果如下:

void *(*start_routine)(void *), void *arg))

35.   int main()

40.   pthread_create(&t1,NULL,(void *)thread1,NULL);

29.       while(1)

thread_return:用户定义的指针,用来囤积被守候线程的重临值(不为NULL时)

49.    

5.    int i=0;

14.       while(1)

30.        i++;

 

53.   return 0;

11.       while(1)

4.   

• 互斥锁判断上锁:pthread_mutex_trylock

48.   pthread_create(&t2,NULL,(void *)thread2,NULL);

27.  

8.        int i=0;

• 互斥锁起初化:pthread_mutex_init

3.    #include<errno.h>

1.    #include<pthread.h>

45.   sem_init(&sem1,0,1);/*早先化信号量sem1*/

15.       {  

6.    pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥锁*/

36.     }

  

20.  

22.       {  

16.             sem_wait(&sem);

线程创制pthread_create()

15.       {  

4.    #include <semaphore.h>

36.   {

35.         sleep(1);

9.        

This is thread2:4

5.   

This is thread2:1

37.   }

52.   pthread_join(t2,NULL);

30.   {

56.   }

31.       {

函数原型int pthread_join ((pthread_t th, void **thread_return))

This is thread2:6

3一块与排斥

5.   

 

20.   /*线程2*/

•sem_wait和sem_trywait也正是P操作,它们都能将信号量的值减一,两者的分别在于若信号量小于零时,  
sem_wait将会阻塞进度,而sem_trywait则会立时回到。

28.        if(i>5)

arg:传递给start_routine的参数

43.    

29.   int main()

19.         sleep(3);/*线程1蛰伏3s,以便观察线程2在出口3s后才会执行*/

thread:线程标识符

43.   }

9.        while(1)

44.  

代码举例

th:等待线程的标识符

38.  

49.   pthread_create(&t2,NULL,(void *)thread2,NULL);

•sem_init用于创建1个信号量,并能早先化它的值。

• 互斥锁接锁:pthread_mutex_unlock

 图片 2

39.         pthread_mutex_unlock(&mutex);

11.   void thread1()

attr:线程属性设置

<2>信号量

•sem_getvalue用于获取信号量的值。

40.        }

40.   }

38.    

相关文章

网站地图xml地图