Linux多线程相关事例

最新推荐文章于 2024-04-02 17:40:47 发布
最新推荐文章于 2024-04-02 17:40:47 发布
阅读量557 收藏
点赞数
分类专栏： linux C
linux多线程例子

一.基本功能

1.最简单例子--创建线程

/*
*
*       创建线程
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        printf("this thread1!\n");
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,NULL);
        sleep(4);
        return 0;
}

2.传递简单参数

/*
*
*       线程传递参数
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        printf("arg=%s\n",prm);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);
        sleep(4);
        return 0;
}

3.传递结构体参数

/*
*
*       线程传递结构体
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

typedef struct prm{
        int in;
        char ch[255];
        int *p;
}oz;

void *thread1(void *arg)
{
        oz *prm2 = NULL;
        prm2=(oz*)arg;
        
        printf(" prm:in=%d\n prm:ch=%s\n prm:p=%d\n",prm2->in,prm2->ch,*(prm2->p));
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        oz *prm1=malloc(sizeof(oz));
        
        prm1->in=3;
        sprintf(prm1->ch,"hello world!");
        prm1->p=malloc(sizeof(prm1->p));
        *(prm1->p)=123456;
        
        ret = pthread_create(&tid,NULL,thread1,(void*)prm1);
        
        sleep(4);
        
        return 0;
}

4.主线程等待子线程结束

/*
*
*       主线程等待子线程结束
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        printf("arg=%s\n",prm);
        sleep(5);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);

        pthread_join(tid,NULL);
        return 0;
}

5.获取线程id

/*
*
*       获取线程id
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        printf("thread1's id=%lu\n",pthread_self());
        sleep(5);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);
        printf("main thread's id=%lu\n",pthread_self());
        printf("child thread's id=%lu\n",tid);
        pthread_join(tid,NULL);
        return 0;
}

6.子线程结束释放资源

/*
*
*       子线程结束释放资源
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        sleep(5);
        pthread_detach(pthread_self());
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);
        pthread_join(tid,NULL);
        return 0;
}

百度百科：
pthread_detach
  
  

   
   创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该
   
   pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid)
  
  

  
  

   
   但是调用pthread_join(pthread_id)后，如果该
   
   线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当
   
   主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码
  
  

  
  

   
   pthread_detach(
   
   pthread_self())
  
  

  
  

   
   或者父线程调用
  
  

  
  

   
   pthread_detach(thread_id)（非阻塞，可立即返回）
  
  

  
  

   
   这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源。

7.创建多个子线程;子线程退出;发送退出信号给子线程

/*
*
*       创建多个子线程;子线程退出;发送退出信号给子线程
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread2(void *arg)
{
        char *prm=NULL;
        int i=5;
        prm=(char*)arg;
        while(1){
                printf("thread2:%s\n",prm);
                sleep(1);
        }
}


void *thread1(void *arg)
{
        char *prm=NULL;
        int i=5;
        prm=(char*)arg;
        while(i--){
                printf("thread1:%s\n",prm);
                sleep(1);
        }
 	pthread_exit("omg!");
        pthread_detach(pthread_self());   
    
}
int main(int argc,char **argv)
{    
    int ret;     
    pthread_t tid1,tid2;        
    void *join_ret;         
    
    ret = pthread_create(&tid1,NULL,thread1,(void*)argv[1]);
    pthread_join(tid1,&join_ret);     
    printf("thread1 exit return:%s\n",(char *)join_ret);  
    
     ret = pthread_create(&tid2,NULL,thread2,(void*)argv[2]);   
     sleep(5);    
     if(!pthread_cancel(tid2))   
          printf("cancel pthread2\n");      
     pthread_join(tid2,NULL);       
     return 0;
}

8.一些错误的判断及处理

/*
*
*       错误的判断及处理
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>

void *thread2(void *arg)
{
        char *prm=NULL;
        int i=5;
        prm=(char*)arg;
        while(1){
                printf("thread2:%s\n",prm);
                sleep(1);
        }
}


void *thread1(void *arg)
{
        char *prm=NULL;
        int i=5;
        prm=(char*)arg;
        while(i--){
                printf("thread1:%s\n",prm);
                sleep(1);
        }
        if(pthread_detach(pthread_self())!=0)
                exit(1);
        pthread_exit("omg!");
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid1,tid2;
        void *join_ret;
        
        ret = pthread_create(&tid1,NULL,thread1,(void*)argv[1]);
        if(ret!=0){     
                printf("can't create thread1: %s\n", (char *)strerror(ret));
                return -1;
        }
        
        if((ret=pthread_join(tid1,&join_ret))!=0){
                printf("pthread_join error %s\n",(char *)strerror(ret));
                return ret;
        }
                
        printf("thread1 exit return:%s\n",(char *)join_ret);
        
        ret = pthread_create(&tid2,NULL,thread2,(void*)argv[2]);
        if(ret!=0){     
                printf("can't create thread2: error num:%d\n", errno);
                return errno;
        }
        
        sleep(5);
        if(!pthread_cancel(tid2)){
                printf("cancel pthread2\n");
        }
        else
                pthread_join(tid2,NULL);
        return 0;
}

9.主线程发送信号给子线程

/*
*
*       主线程发送信号给子线程
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>

void kill_handler(int i)
{
        printf("kill_handler\n");
}

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        printf("arg=%s\n",prm);
        while(1)
                ;
}

int main(int argc,char **argv)

{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);
        
        signal(SIGQUIT,kill_handler);
        sleep(5);
        
        if(pthread_kill(tid,SIGQUIT)==0)
                printf("signal to pthread!\n");
        while(1)
                ;
        return 0;
}

10.pthread_cleanup_push/pop

/*
*
*       pthread_cleanup_push/pop
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void cleanup(void *arg)
{
        char* prm=NULL;
        prm=(char*)arg;
        printf("cleanup arg=%s\n",prm);
}

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        pthread_cleanup_push(cleanup,(void*)prm);
        printf("arg=%s\n",prm);
        pthread_cleanup_pop(1);
}

int main(int argc,char **argv)

{
        int ret;
        pthread_t tid;
        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);

        pthread_join(tid,NULL);
        return 0;
}


二.线程同步

第1部分 线程属性

1.detachstate

/*
*
*       detachstate
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{

        char *prm=NULL;
        prm=(char*)arg;         
        printf("arg=%s\n",prm);
        sleep(5);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        pthread_attr_t attr;
        int detachstate;
        pthread_attr_init(&attr); 

        pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
        
        ret = pthread_create(&tid,&attr,thread1,(void*)argv[1]);
        if(ret!=0){
                printf("pthread_create fail!\n");
                return ret;
        }
        
        ret = pthread_attr_getdetachstate (&attr, &detachstate);
        if(ret!=0){
                printf("pthread_attr_getdetachstate error!\n");
        }
        if((detachstate==PTHREAD_CREATE_DETACHED)||(detachstate==PTHREAD_CREATE_JOINABLE)){
                if(detachstate==PTHREAD_CREATE_DETACHED)
                        printf("PTHREAD_CREATE_DETACHED\n");
                else
                        printf("PTHREAD_CREATE_JOINABLE\n");
        }
        pthread_attr_destroy(&attr);
        pthread_join(tid,NULL);
        return 0;
}

2.guardsize

/*
*
*       guardsize
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        printf("arg=%s\n",prm);
        sleep(5);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;
        pthread_attr_t attr;
        size_t  guardsize;
        
        pthread_attr_init(&attr); 

        pthread_attr_setguardsize(&attr,4093);
        ret = pthread_create(&tid,&attr,thread1,(void*)argv[1]);
        if(ret!=0){
                printf("pthread_create fail!\n");
                return ret;
        }
        
        ret = pthread_attr_getguardsize (&attr, &guardsize);
        if(ret!=0){
                printf("pthread_attr_getguardsize error!\n");
        }
        else{
                printf("guardsize=%d\n",guardsize);
        }
        
        pthread_attr_destroy(&attr);
        pthread_join(tid,NULL);
        return 0;
}

3.inheritsched

/*
*
*       inheritsched
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        int ret;
        pthread_attr_t attr;
        int inheritsched;
        
        pthread_attr_init(&attr); 
        pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED);
        
        printf("arg=%s\n",prm);
        sleep(5);

        ret = pthread_attr_getinheritsched(&attr, &inheritsched);
        if(ret!=0){
                printf("pthread_attr_getguardsize error!\n");
        }
        
        if((inheritsched==PTHREAD_INHERIT_SCHED)||(inheritsched==PTHREAD_EXPLICIT_SCHED)){
                if(inheritsched==PTHREAD_INHERIT_SCHED)
                        printf("PTHREAD_INHERIT_SCHED\n");
                if(inheritsched==PTHREAD_EXPLICIT_SCHED)
                        printf("PTHREAD_EXPLICIT_SCHED\n");
        }
        
        pthread_attr_destroy(&attr);
}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid;

        ret = pthread_create(&tid,NULL,thread1,(void*)argv[1]);
        if(ret!=0){
                printf("pthread_create fail!\n");
                return ret;
        }
        
        
        pthread_join(tid,NULL);
        return 0;
}

 

第2部分 mutex

1.mutex简单应用

//这个例子不好，可能无休止的运行，sum++的位置，及 sum 的判断条件，

使用trylock应该根据函数的返回值来决定是否进行sum的操作这才是正确的操作方式

/*
*
*       mutex简单应用
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex;
int sum=0;
void *thread3(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        sleep(2);
        pthread_mutex_trylock(&mutex);
        while(1){
                sum++;
                if(sum==10)
                        break;
                printf("thread3:%d\n",sum);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);
}


void *thread2(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;
        sleep(1);
        pthread_mutex_lock(&mutex);
        while(1){
                sum--;
                if(sum<0)
                        break;
                printf("thread2:%d\n",sum);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);
}


void *thread1(void *arg)
{
        char *prm=NULL;
        prm=(char*)arg;

        pthread_mutex_lock(&mutex);
        while(1){
                sum++;
                if(sum==10)
                        break;
                printf("thread1:%d\n",sum);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);
}

int main(int argc,char **argv)

{
        int ret;
        pthread_t tid1,tid2,tid3;
        pthread_mutex_init(&mutex,NULL);
        ret = pthread_create(&tid1,NULL,thread1,(void*)argv[1]);
        ret = pthread_create(&tid2,NULL,thread2,(void*)argv[1]);
        ret = pthread_create(&tid3,NULL,thread2,(void*)argv[1]);
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);
        pthread_join(tid3,NULL);
        pthread_mutex_destroy(&mutex);
        return 0;
}

pthread_mutex_trylock/lock区别
本质区别不就在“try”吗

选哪个取决于场景：
当前线程锁失败，也可以继续其它任务，用trylock合适
当前线程只有锁成功后，才会做一些有意义的工作，那就_lock，没必要轮询trylock

2.进程mutex

//此例程中共享内存使用有些问题，下面的程序若将“尝试注释”代码部分注释，加锁不能堵塞。重新使用一个新的pthread_mutex_t变量，则能正常使用

/*
*
*       进程mutex
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/ipc.h>

typedef struct dev{
        int i;
        pthread_mutex_t mutex;
}DEV;
int main(int argc,char **argv)
{
        int ret;
        DEV *device=malloc(sizeof(DEV));
        unsigned long j=0;
        pthread_mutexattr_t mutexattr;
        int shmid;
        shmid=shmget(123,sizeof(DEV*),IPC_CREAT|0660);
        shmctl(shmid,IPC_RMID,0);
        shmid=shmget(123,sizeof(DEV*),IPC_CREAT|0660);
        if(shmid==-1)
                perror("shmget()");
        device=(DEV*)shmat(shmid,0,0);
        pthread_mutexattr_init(&mutexattr);        pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_SHARED);                pthread_mutex_init(&(device->mutex),&mutexattr);        ret = fork();        if(ret==-1){                printf("fork error!\n");        }        if (ret==0){               
                //将此句放到进城创建之前device=(DEV*)shmat(shmid,0,0);
                printf("father!\n");                char buffer[1024];                while(1){                        pthread_mutex_lock(&(device->mutex));                        (device->i)--;                        printf("father : i = %d\n",(device->i));                        //pthread_mutex_unlock(&(device->mutex));//尝试注释                        sleep(1);                }                pthread_mutexattr_destroy(&mutexattr);                pthread_mutex_destroy(&(device->mutex));                return 0;        }        else{                printf("child!\n");                //放到进城创建之前device=(DEV*)shmat(shmid,0,0);                while(1){                        pthread_mutex_lock(&(device->mutex));                        (device->i)++;                        printf("child : i = %d\n",(device->i));                        pthread_mutex_unlock(&(device->mutex));                        sleep(1);                }      
                pthread_mutexattr_destroy(&mutexattr);
                pthread_mutex_destroy(&(device->mutex));
        
                return 0;        }}
 
 
//修改之后的程序
 
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/ipc.h>


typedef struct dev
{
	int i;
	pthread_mutex_t mutex;
}DEV;


int main(int argc,char *argv[])
{
	int ret;
	DEV *device = malloc(sizeof(DEV));
	unsigned long j = 0;
	pthread_mutexattr_t mutexattr;
	pthread_mutex_t ev;
	int shmid;


	shmid = shmget(123,sizeof(DEV*),IPC_CREAT|0660);
	shmctl(shmid,IPC_RMID,0);


	shmid = shmget(123,sizeof(DEV*),IPC_CREAT|0660);
	if(shmid == -1)
	{
		perror("shmget()");
	}


	device = (DEV*)shmat(shmid,NULL,0);


	pthread_mutexattr_init(&mutexattr);
	pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_SHARED);


	pthread_mutex_init(&(device->mutex),&mutexattr);
	pthread_mutex_init(&ev,NULL);
	ret = fork();


	if(ret == -1)
	{
		printf("fork error\n");
	}
	if(ret == 0)
	{
		//father
		printf("father\n");
		char buffer[1024];


		while(1)
		{
//			pthread_mutex_lock(&ev);
//			printf("lock ev\n");
			pthread_mutex_lock(&(device->mutex));
			printf(" father lock share mutex\n");


		//	(device->i)--;
			(device->i)++;
			printf("father: i = %d\n",device->i);
			pthread_mutex_unlock(&(device->mutex));
			sleep(1);
		}
		printf("father while out\n");
		pthread_mutexattr_destroy(&mutexattr);
		pthread_mutex_destroy(&(device->mutex));
		return 0;
	}
	else
	{
		sleep(5);
		
		printf("child!\n");
		device = (DEV*)shmat(shmid,0,0);
		while(1)
		{
			pthread_mutex_lock(&(device->mutex));
			(device->i)--;
			printf("child: i = %d\n",device->i);
			pthread_mutex_unlock(&(device->mutex));
			sleep(1);
		}
		pthread_mutexattr_destroy(&mutexattr);
		pthread_mutex_destroy(&(device->mutex));
	
		return 0;
	}


}

  
  


  
  


 
 
 3.线程mutex
 
 
/*
*
*       线程mutex
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

int i=0;
char buffer[1024];
pthread_mutex_t mutex;

void *thread2(void *arg)
{
        while(1){
                pthread_mutex_lock(&mutex);
                i++;
                printf("thread2 %d\n",i);
                if(fgets(buffer,1024,stdin)!=NULL) 
                        pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

void *thread1(void *arg)
{
        while(1){
                pthread_mutex_lock(&mutex);
                i--;
                printf("thread1 %d\n",i);
                if(fgets(buffer,1024,stdin)!=NULL) 
                        pthread_mutex_unlock(&mutex);
                sleep(1);
        }

}

int main(int argc,char **argv)
{
        int ret;
        pthread_t tid1,tid2;
        pthread_mutexattr_t mutexattr;
        
        pthread_mutexattr_init(&mutexattr);
        pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_PRIVATE);
        pthread_mutex_init(&mutex,&mutexattr);
        ret = pthread_create(&tid1,NULL,thread1,NULL);
        ret = pthread_create(&tid1,NULL,thread2,NULL);
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);
        pthread_mutexattr_destroy(&mutexattr);
        pthread_mutex_destroy(&mutex);
        return 0;
}

 
 
 自己的程序
 
 
 
 
 
 #include <stdio.h>
 
 
 #include <stdlib.h>
 
 
 #include <pthread.h>
 
 
 #include <unistd.h>
 
 
 
 
 
 
int i=0;
 
 
char buffer[1024];
 
 
pthread_mutex_t mutex;
 
 
 
 
 
 
void *thread2(void *arg)
 
 
{
 
 
 while(1)
 
 
{
 
 
pthread_mutex_lock(&mutex);
 
 
i++;
 
 
 printf("thread2:%d\n",i);
 
 
if(fgets(buffer,1024,stdin)!=NULL)
 
 
{
 
 
pthread_mutex_unlock(&mutex);
 
 
 printf("thread2 unlock\n");
 
 
}
 
 
sleep(1);
 
 
}
 
 
}
 
 
 
 
 
 
void *thread1(void * arg)
 
 
{
 
 
 while(1)
 
 
{
 
 
pthread_mutex_lock(&mutex);
 
 
i--;
 
 
 printf("thread1:%d\n",i);
 
 
 
 
 
 
if(fgets(buffer,1024,stdin)!=NULL)
 
 
{
 
 
pthread_mutex_unlock(&mutex);
 
 
 printf("thread1 unlock\n");
 
 
}
 
 
sleep(1);
 
 
}
 
 
}
 
 
 
 
 
 
int main(int argc,char *argv[])
 
 
{
 
 
int ret;
 
 
pthread_t tid1,tid2;
 
 
pthread_mutexattr_t mutexattr;
 
 
 
 
 
 
pthread_mutexattr_init(&mutexattr);
 
 
pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_PRIVATE);
 
 
 
 
 
 
pthread_mutex_init(&mutex,&mutexattr);
 
 
ret = pthread_create(&tid1,NULL, thread1,NULL);
 
 
ret = pthread_create(&tid2,NULL, thread2,NULL);
 
 
 
 
 
pthread_join(tid1,NULL);
 
 
pthread_join(tid2,NULL);
 
 
 
 
 
 
pthread_mutexattr_destroy(&mutexattr);
 
 
pthread_mutex_destroy(&mutex);
 
 
 
 
 
 
 return0;
 
 
 
 
 
 
}
 
 
 
  
 
 
 
 
 第3部分 条件变量 
 
 1.线程+mutex+cond 
 
/*
*
*       线程+mutex+cond
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
int i=0;

void *thread2(void *arg)
{
        while(i!=30){
                pthread_mutex_lock(&mutex);
                
                i++;
                if(!(i%6))
                        pthread_cond_signal(&cond);
                printf("thread2 %d\n",i);
                
                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

void *thread1(void *arg)
{
        while(i!=30){
                pthread_mutex_lock(&mutex);
                
                pthread_cond_wait(&cond,&mutex);
                printf("thread1-%d\n",i);

                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}


int main(int argc,char **argv)
{
        int ret;
        pthread_t tid1,tid2;

        pthread_condattr_t attr;
        pthread_mutexattr_t mutexattr;
        
        pthread_mutexattr_init(&mutexattr);
        pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_PRIVATE);

        pthread_condattr_init(&attr);
        pthread_condattr_setpshared(&attr,PTHREAD_PROCESS_PRIVATE);
        
        pthread_mutex_init(&mutex,&mutexattr);  
        pthread_cond_init(&cond,&attr);
        
        ret = pthread_create(&tid1,NULL,thread1,(void*)argv[1]);
        ret = pthread_create(&tid2,NULL,thread2,(void*)argv[1]);
        
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);
        printf("all thread done!\n");
        pthread_condattr_destroy(&attr);
        pthread_cond_destroy(&cond);
        
        pthread_mutexattr_destroy(&mutexattr);
        pthread_mutex_destroy(&mutex);
        return 0;
}

 
 
 
 线程+mutex+cond+互锁
 
 
 
 
 
 
 //这个程序很烂，上锁和解锁不配对，逻辑混乱，非常容易造成死锁，全局变量i都没有设置，没有全局的结束变量。
 
 
 关于cond参考之后的关于pthread_cond_wait和pthread_cond_signal博客文章，
 
 
/*
*
*       线程+mutex+cond+互锁
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
int i=0;
char buffer[1024];

void *thread2(void *arg)
{
        while(i!=30){
                pthread_mutex_lock(&mutex);
                if(fgets(buffer,1024,stdin)!=NULL){
                        if(buffer[0]!='2'){
                        pthread_cond_signal(&cond);
                        printf("thread2 pthread_cond_signal\n");
                        pthread_mutex_unlock(&mutex);
                        }
                }
                else{
                        printf("thread2 pthread_cond_wait\n");
                        pthread_cond_wait(&cond,&mutex);
                        
                }
                printf("thread2 running\n");
                sleep(1);
        }
}

void *thread1(void *arg)
{
        while(i!=30){
                pthread_mutex_lock(&mutex);
                if(fgets(buffer,1024,stdin)!=NULL){
                        if(buffer[0]!='1'){
                        pthread_cond_signal(&cond);
                        printf("thread1 pthread_cond_signal\n");
                        pthread_mutex_unlock(&mutex);
                        }
                }
                else{
                        printf("thread1 pthread_cond_wait\n");
                        pthread_cond_wait(&cond,&mutex);
                        
                }
                printf("thread1 running\n");
                sleep(1);
        }
}


int main(int argc,char **argv)

{
        int ret;
        pthread_t tid1,tid2;

        pthread_condattr_t attr;
        pthread_mutexattr_t mutexattr;
        
        pthread_mutexattr_init(&mutexattr);
        pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_PRIVATE);

        pthread_condattr_init(&attr);
        pthread_condattr_setpshared(&attr,PTHREAD_PROCESS_PRIVATE);
        
        pthread_mutex_init(&mutex,&mutexattr);  
        pthread_cond_init(&cond,&attr);
        
        ret = pthread_create(&tid1,NULL,thread1,(void*)argv[1]);
        ret = pthread_create(&tid2,NULL,thread2,(void*)argv[1]);
        
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);
        printf("all thread done!\n");
        pthread_condattr_destroy(&attr);
        pthread_cond_destroy(&cond);
        
        pthread_mutexattr_destroy(&mutexattr);
        pthread_mutex_destroy(&mutex);
        return 0;
}

 
 
 
 
  
 
 
  
 


                

        

        

    

  


    

      

        

            

              
                
                  G1036583997
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
linux高效率编程：epoll和多线程

				
			

			

				

					生活在别处
				

				

					01-10
					
					1万+
					
				

			

		

		

			
				
一个发送压力工具的Demo，主要是演示相关技术的使用。
在linux下使用多线程、epoll编程、socket编程技术实现，系统设置为'ulimit -n' > 10240，可以稳定达到短连接上万的连接，长连接5000个。
设计要点如下：
1. 主函数中循环读取请求数据，新建的3个子线程分别去建立连接，发送请求，接收请求。会初始化2个epoll来分别监听可以写数据（发送请求）的事件和可以读数据（接收请求）的事件。
2. 使用的数据结构为，将socket句柄和相关操作封装在query类中，该query类带有前

			
		

	



                

              
                



	

		

			

				
					
Linux线程（六）

				
			

			

				

					wolfGuiDao的博客
				

				

					01-14
					
					714
					
				

			

		

		

			
				
Linux线程（六）
一、线程池：
1.线程池：

线程池是一种使用模式。线程过多会带来调度开销，进而影响缓存的局部性和整体性能。而线程池维护着多个线程，等待监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建和销毁线程的代价。线程池内部不仅能够保证内核的充分利用，还能防止过度调度。可线程的数量应该取决于可用的并发处理器、处理器内核、内存、网络socket等的数量

2.应用场景：

需...

			
		

	



                


  
              

                


	

		

			

				
					
一个最简单的多线程例子

				
			

			

				

					11-20
				

			

		

		

			
				
用vc编写的最简单的多线程示例，该示例是关于一个时间显示，将操作与界面显示分离，适用于初学者。

			
		

	





	

		

			

				
					
linux 多线程小例子

				
			

			

				

					hubi0952的专栏
				

				

					10-06
					
					1823
					
				

			

		

		

			
				
先看一个有问题的例子：

#include 
#include 
#include 
#include 
#include 
#include 

void * pthread_function(void * arg);

#define MAX_SIZE 10

int main(int argc, char const *argv[])
{
	pthread_t pthread[MAX_S

			
		

	



		

			
		



	

		

			

				
					
多线程例子

				
			

			

				

					xiaodeguang的博客
				

				

					02-25
					
					548
					
				

			

		

		

			
				
#include 
#include 
using namespace std;

DWORD WINAPI Fun1Proc(
  LPVOID lpParameter   // thread data
);

DWORD WINAPI Fun2Proc(
  LPVOID lpParameter   // thread data
);
int index=0;
int tickets=100;

			
		

	





	

		

			

				
					
多线程案例

				
			

			

				

					lfm1010123的博客
				

				

					07-19
					
					674
					
				

			

		

		

			
				
一、单例模式
二、阻塞式队列
三、定时器
四、线程池
五、工厂模式

			
		

	





	

		

			

				
					
linux的多线程举例,Linux系统下Shell多线程编程的实例

				
			

			

				

					weixin_31349405的博客
				

				

					05-07
					
					118
					
				

			

		

		

			
				
#!/bin/bash#———————————————————————————–# 此例子说明了一种用wait、read命令模拟多线程的一种技巧# 此技巧往往用于多主机检查，比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况# 还说明了多线程的控制#———————————————————————————–function a_sub{# 此处定义一个函数，作为一个线程(子进程)sle...

			
		

	





	

		

			

				
					
Java多线程案例之线程池

				
			

			

				

					m0_71563599的博客
				

				

					06-05
					
					243
					
				

			

		

		

			
				
:star:️ 前面的话 :star:️本篇文章将介绍多线程案例，线程池，线程在Linux中也叫做轻量级线程，尽管线程比进程较轻，但是如果线程的创建和销毁频率高了，开销也还是有的，为了进一步提高效率，引入了线程池，和字符串常量池类似，把线程提前创建好，放到一个“池子”里面，后面使用的时候，速度就快了，但是代价就是空间，线程池本质上也还是空间换时间。线程池和字符串常量池一样，都是为了提高程序运行效率而提出的效率，程序中每创建一个线程就会把该线程加载到一个“池子”中去，其实这个池子就是List，当程序下次需要调

			
		

	





	

		

			

				
					
【C/C++】Linux多进程开发

					
最新发布

				
			

			

				

					love_boke的博客
				

				

					04-02
					
					1976
					
				

			

		

		

			
				
提示：这里可以添加本文要记录的大概内容：提示：以下是本篇文章正文内容，下面案例可供参考并行与并发01 /进程间通讯概念◼ 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。◼ 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( **IPC：Inter Processes Communication** )。

			
		

	





	

		

			

				
					
Linux C/C++并发编程实战（5）内存屏障是什么？

				
			

			

				

					二进制君
				

				

					03-26
					
					960
					
				

			

		

		

			
				
全屏障（Full Barrier）是一种内存屏障，用于控制 CPU 的执行顺序，确保在执行全屏障之前的所有指令都已经执行完毕，避免指令重排等问题。同步屏障会阻塞当前 CPU 的指令流水线，并等待其他指令流水线中之前的指令执行完成，从而确保在同一时间点上，所有线程或处理器中对于共享内存的修改都已经执行完毕，并且禁止之前的指令进行重排，从而保证了程序的正确性。不合理的内存屏障会影响程序的性能，因此建议开发者在设计和优化程序时，要深入理解内存屏障的机制和作用，避免过度依赖内存屏障。

			
		

	





	

		

			

				
					
linux C 多线程编程典型实例

				
			

			

				

					08-01
				

			

		

		

			
				
linux c 开发中多线程的典型实例，可在linux平台直接运行，通过实践熟悉理解多线程工作原理。

			
		

	





	

		

			

				
					
今天没事给大家写一个多线程例子

				
			

			

				

					07-09
				

			

		

		

			
				
今天没事给大家写一个多线程例子
今天没事给大家写一个多线程例子

			
		

	





	

		

			

				
					
Linux中多线程详解及简单实例

				
			

			

				

					01-20
				

			

		

		

			
				
Linux中多线程详解及简单实例
1.概念 

进程：运行中的程序。 

线程：一个程序中的多个执行路径。更准确的定义是：线程是一个进程内部的一个控制序列。 

2.为什么要有线程？ 

用fork调用进程代价太高，需要让一个进程同时做多件事情，线程就非常有用。 

3.线程的优点和缺点。 

优点： 

（1）有时，让程序看起来是在同时做两件事是非常有用的。 比如在编辑文档时，还能统计文档里的单词个数。 
（2）一个混杂着输入、计算、输出的程序，利用线程可以将这3个部 分分成3个线程来执行，从而改变程序执行的性能。 
（3）一般来说，线程之间切换需要操作系统所做的工作比进程间切换需要的代价小

			
		

	





	

		

			

				
					
多线程示例

				
			

			

				

					03-30
				

			

		

		

			
				
MFC窗口程序多线程示例 MFC窗口程序多线程示例 MFC窗口程序多线程示例

			
		

	





	

		

			

				
					
多线程简单实例

				
			

			

				

					mengxiangjia_linxi的博客
				

				

					09-20
					
					270
					
				

			

		

		

			
				
线程：线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源， 
但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的

			
		

	





	

		

			

				
					
Linux 平台多线程编程实例

				
			

			

				

					Maddock的专栏
				

				

					10-06
					
					2613
					
				

			

		

		

			
				
转载请注明出去 http://blog.csdn.net/adong76/article/details/39674523
	参考博客：
http://www.cnblogs.com/armlinux/archive/2010/05/28/2396997.html
	http://blog.csdn.net/hitwengqi/article/details/8015646
	http:/

			
		

	





	

		

			

				
					
一个例子玩转linux多线程问题（创建 执行 条件变量 ......）

				
			

			

				

					weixin_30909575的博客
				

				

					06-20
					
					331
					
				

			

		

		

			
				
一个例子玩转linux多线程问题（创建 执行 条件变量 ......）


ZZ自http://hi.baidu.com/��ѩ����/blog/item/b18de21cbf0ad3024134179a.html
这是在网上找的一篇介绍linux多线程的文章
主要介绍了linux下多线程的一些基本的操作，感觉不错，用一个例子进行讲解的，对我的帮助不小，耐心的看完它，对你也是一种益处。...

			
		

	





	

		

			

				
					
linux中线程例子,Linux多线程编程(3)——实例分析

				
			

			

				

					weixin_35422396的博客
				

				

					05-06
					
					257
					
				

			

		

		

			
				
1、背景说明：MJPG-streamer是一个开源软件，它可从一个输入插件复制JPG帧到多个输出插件。它的输入插件从摄像头、文件系统或其它输入插件读取视频数据，并复制到内存中，它有多个输出插件将这些视频数据经过处理，其中最重要的输出插件是网站服务器插件，它将视频帧以M-JPEG流的形式通过基于ip的网络传输到浏览器如Firefox，Cambozola，VLC播放器，Windows的移动设备或者其他...

			
		

	





	

		

			

				
					
Linux多线程编程详解：pthread实践与指南

				
			

			

				

					
				

			

		

		

			
				
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。  1. **概述...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值