《APUE》chapter 11 Thread 学习笔记(加上自己的代码)_thread id of the calling process

#include"apue.h"
#include"myerr.h"
#include<pthread.h>
 
 
struct foo
{
         int a,b,c,d;
};
 
 
//struct foo foo ={1,2,3,4};
 
 
void printfoo(const char*s,const struct foo* fp)
{
        printf(s);
        printf("structure at 0x%x\n",(unsigned)fp);
        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_fn1(void* arg)
{
        struct foo foo ={1,2,3,4};
        printfoo("thread 1:\n",&foo);
        pthread_exit((void*)&foo);
}
 
 
void* thr_fn2(void* arg)
{
        printf("thread 2: ID is %d\n",pthread_self());
        pthread_exit((void*) 0);
}
int main()
{
        int err;
        pthread_t tid1,tid2;
        struct foo *fp;
 
 
        err = pthread_create(&tid1,NULL,thr_fn1,NULL);
        if(err != 0)
        {
                err_quit("can't creat thread 1:%s\n",strerror(err));
        }
 
 
        err = pthread_join(tid1,(void*) &fp);
        if(err != 0)
        {
                err_quit("can't join with thread 1:%s\n",strerror(err));
        }
 
 
        sleep(1);
        printf("parent starting second thread \n");
        err = pthread_create(&tid2,NULL,thr_fn2,NULL);
        if(err != 0)
        {
                err_quit("can't creat thread 2:%s\n",strerror(err));
        }
 
 
        sleep(1);
        printfoo("parent:\n",fp);
        exit(0);
}

jasonleaster@ubuntu:/Ad_Pro_in_Unix/chapter_11$ ./a.out
thread 1:
structure at 0x88082e90
 foo.a = 1
 foo.b = 2
 foo.c = 3
 foo.d = 4
parent starting second thread 
thread 2: ID is -2012727552
parent:
structure at 0x88082e90
 foo.a = 0
 foo.b = 0
 foo.c = 1
 foo.d = 0

这个demo在我看来。。。除了说明一下thread之外无非就是说了一个局部自动变量的作用范围问题。。。

只要把上面我注释掉的部分，用起来(就是把注释符号去掉)。并且注释掉局部的foo

那么就可以有下面这种结果

jasonleaster@ubuntu:/Ad_Pro_in_Unix/chapter_11$ ./a.out
thread 1:
structure at 0x6020c0
 foo.a = 1
 foo.b = 2
 foo.c = 3
 foo.d = 4
parent starting second thread 
thread 2: ID is -430766336
parent:
structure at 0x6020c0
 foo.a = 1
 foo.b = 2
 foo.c = 3
 foo.d = 4

#include <pthread.h>
int pthread_cancel(pthread_t tid);
Returns: 0 if OK, error number on failure
 
#include <pthread.h>
void pthread_cleanup_push(void (* rtn)(void *), void *arg);
void pthread_cleanup_pop(int execute );

demo:

#include "apue.h"
#include "myerr.h"
#include "pthread.h"
 
 
void cleanup(void *arg)
{
        printf("clearn up :%s\n",(char*)arg);
}
 
 
void *thr_fn1(void *arg)
{
        printf("thread 1 start\n");
        pthread_cleanup_push(cleanup,"thread 1 first handler\n");
        pthread_cleanup_push(cleanup,"thread 1 second hanler\n");
        printf("thread 1 push complete\n");
 
 
        if(arg)
        {
                return((void*) 1);
        }
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        return ((void*) 1);
}
 
 
void *thr_fn2(void *arg)
{
        printf("thread 2 start\n");
        pthread_cleanup_push(cleanup,"thread 2 first handler");
        pthread_cleanup_push(cleanup,"thread 2 second handler");
        printf("thread 2 push complete\n");
 
 
        if(arg)
        {
                pthread_exit((void*) 2);
        }
 
 
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(0);
        pthread_exit((void*) 2);
int main()
{
        int err;
        pthread_t tid1,tid2;
        void* tret;
 
 
        err = pthread_create(&tid1,NULL,thr_fn1,(void*) 1);
        if(err != 0)
        {
                err_quit("can't create thread 1 :%s\n",strerror(err));
        }
 
 
        err = pthread_create(&tid2,NULL,thr_fn2,(void*) 2);
        if(err != 0)
        {
                err_quit("can't create thread 2 :%s\n",strerror(err));
        }
 
 
        err = pthread_join(tid1,&tret);
        if(err != 0)
        {
                err_quit("can't join with thread 1:%s\n",strerror(err));
        }
 
 
        printf("thread 1 exit code %d\n",(int)tret);
        err = pthread_join(tid2,&tret);
        if(err != 0)
        {
                err_quit("can't join with thread 2:%s\n",strerror(err));
        }
 
 
        printf("thread 2 exit code %d\n",(int)tret);
 
 
        return 0;
}

        if the thread terminates by returning from its start routine, its cleanup handlers are not called, although this behavior varies among  implementations. Also  note  that  the  cleanup  handlers  are called  in  the  reverse order from which they were installed.

        By  default,  a  thread’s  termination  status  is  retained  until  we  call pthread_join for  that  thread.

        After a thread is detached, we can’t use the pthread_join function  to  wait  for  its  termination  status,  because calling pthread_join for  a  detached  thread  results  in  undefined  behavior.

进程线程相关函数对比：

Thread Synchronization

        When  one  thread  modifies  a  variable,  other  threads  can  potentially  see inconsistencies  when  reading  the  value  of  that  variable.

         If  two  threads try  to  increment  the  same  variable  at  almost  the  same  time  without synchronizing with each other ,the results can be inconsistent. 

        Figure11.7  shows  a  hypothetical  example  of  two  threads  reading  and  writing  the same variable. In this example, thread A reads the variable and then writes a new value to  it,  but  the  write  operation  takes  two memory cycles. If  thread  B  reads  the  same variable between the two write cycles, it will see an inconsistent value.

        To  solve this problem, the threads have to use a lock that will allow only one thread to  access  the  variable  at  a  time.

Mutexes

In this way ,only one thread will proceed at a time.

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrictattr );
int pthread_mutex_destroy(pthread_mutex_t * mutex);
Both return: 0 if OK, error number on failure
 
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t * mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
All return: 0 if OK, error number on failure

          If  a  thread  can’t  afford to block,  it  can  use pthread_mutex_trylock to  lock  the mutex  conditionally. If the  mutex  is  unlocked  at  the  time pthread_mutex_trylock is  called,  then pthread_mutex_trylock will  lock  the  mutex  without  blocking  and return  0. Otherwise, pthread_mutex_trylock will  fail,  returning EBUSY without locking the mutex.

测试pthread_mutexes_trylock 和pthread_mutexes_lock貌似我还没找出区别。。。测试结果差不多

最重要的还是demo:........

#include"stdio.h"
#include"stdlib.h"
#include<pthread.h>
#include"string.h"
 
 
void *myfunc1(void* ptr);
void *myfunc2(void* ptr);
 
 
pthread_mutex_t lock;
int a[100];
 
 
int main()
{
        pthread_t thrd1,thrd2;
        int thret1,thret2;
        char* msg1 = "First thread";
        char* msg2 = "Second thread";
 
 
        memset(a,0,sizeof(a));
 
 
        thret1 = pthread_create(&thrd1,NULL,myfunc1,(void *)msg1);
        thret2 = pthread_create(&thrd2,NULL,myfunc2,(void *)msg2);
 
 
        pthread_join(thrd1,NULL);
        pthread_join(thrd2,NULL);
 
 
        printf("thret1 = %d\n",thret1);
        printf("thret2 = %d\n",thret2);
 
 
        return 0;
}
 
void* myfunc1(void* ptr)
{
        int i;
        char* msg = (char*) ptr;
        printf("msg: %s\n",msg);
 
 
        pthread_mutex_lock(&lock);
        for(i = 0;i < 100;i++)
        {
                printf("X");
                a[i] = i;
        }
        printf("\n");
        pthread_mutex_unlock(&lock);
}
 
 
void* myfunc2(void* ptr)
{
        int i;
        char* msg =(char*)ptr;
        printf("msg: %s\n",msg);
 
 
        pthread_mutex_lock(&lock);
        for(i = 0;i< 100;i++)
        {
                printf("%d, ",a[i]);
        }
        printf("\n");
        pthread_mutex_unlock(&lock);
}

#include "apue.h"
#include <pthread.h>
#include "myerr.h"
 
 
struct foo
{
        int f_count;
        pthread_mutex_t f_lock;
};
 
 
struct foo* foo_alloc(void);
 
 
void foo_hold(struct foo*fp);
 
 
void foo_rele(struct foo*fp);
 
 
void *myfunc1(void* ptr);
void *myfunc2(void* ptr);
 
 
 
 
int a[100];
 
 
int main()
{
        int err = 0;
 
 
        int thret1,thret2;
        pthread_t thrd1,thrd2;
        struct foo* fp = NULL;
 
 
        memset(a,0,sizeof(a));
 
 
        fp = foo_alloc();
 
 
        thret1 = pthread_create(&thrd1,NULL,myfunc1,(void *)fp);
        thret2 = pthread_create(&thrd2,NULL,myfunc2,(void *)fp);
 
 
 
        if((err = pthread_join(thrd1,NULL)) != 0)
        {
                printf("join error %s\n",strerror(err));
        }
 
 
        if((err = pthread_join(thrd2,NULL)) != 0)
        {
                printf("join error %s\n",strerror(err));
        }
 
 
        printf("thret1 = %d\n",thret1);
        printf("thret2 = %d\n",thret2);
        return 0;
}
 
 
struct foo* foo_alloc(void)
{
        struct foo* fp;
 
 
        if((fp = malloc(sizeof(struct foo))) != NULL)
        {
                fp->f_count = 1;
                if(pthread_mutex_init(&fp->f_lock,NULL) != 0)
                {
                        free(fp);
                        return NULL;
                }
 
 
                /*continue initialization*/
        }
        return (fp);
}
 
 
void foo_hold(struct foo*fp)
{
        pthread_mutex_lock(&fp->f_lock);
        fp->f_count++;
//      pthread_mutex_unlock(&fp->f_lock);
}
 
void foo_rele(struct foo*fp)
{
//      pthread_mutex_lock(&fp->f_lock);
        if(--fp->f_count == 0)
        {
                pthread_mutex_unlock(&fp->f_lock);
                pthread_mutex_destroy(&fp->f_lock);
                free(fp);
        }
        else
        {
                pthread_mutex_unlock(&fp->f_lock);
        }
}
 
 
void* myfunc1(void* ptr)
{
        int i;
        struct foo* fp  = (struct foo*) ptr;
 
 
        foo_hold(fp);
 
 
        printf("msg: thread 1\n");
 
 
        for(i = 0;i < 100;i++)
        {
                printf("X");
                a[i] = i;
        }
        printf("\n");
        foo_rele(fp);
}
 
void* myfunc2(void* ptr)
{
        int i;
        struct foo* fp  = (struct foo*) ptr;
 
 
        foo_hold(fp);
 
 
        printf("msg: thread2\n");
 
 
        for(i = 0;i< 100;i++)
        {
                printf("%d, ",a[i]);
        }
        printf("\n");
        foo_rele(fp);
}

Deadlock Avoidance

A thread  will  deadlock  itself  if  it  tries  to  lock  the  same  mutex  twice。

For example, when we use more than one  mutex  in  our  programs,  a  deadlock  can  occur  if  we  allow  one thread  to  hold  a mutex  and  block  while  trying  to  lock  a  second  mutex  at  the  same  time  that  another
thread  holding  the  second  mutex  tries  to  lock  the  first  mutex.

作者给的示意性代码真心有问题。

http://blog.csdn.net/cinmyheart/article/details/22863095

以后我自己写个demo不上来。。。吧。。。

Reader–writer locks

           Reader–writer locks are similar to mutexes, except that they allow for higher degrees of parallelism.  With  a  mutex, the  state  is  either  locked  or  unlocked,  and  only  one  thread can lock it at a time. Three states are possible with a reader–writer lock: locked in read mode,  locked  in  write  mode,  and  unlocked. Only  one  thread  at  a  time  can  hold  a reader–writer lock in write mode, but multiple threads can hold a reader–writer lock in read mode at the same time.

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrictrwlock ,
const pthread_rwlockattr_t *restrict attr );
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock );
Both return: 0 if OK, error number on failure
 
#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock );
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock );
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock );
All return: 0 if OK, error number on failure
 
#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock );
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock );
Both return: 0 if OK, error number on failure

API和mutexes的差不多。最终看看demo就行了

未完待续。。。有部分demo没有给出，近日将给出demo。并更改blog的结构，添加更多的细节