c语言多线程的作用是什么,pthread多线程(C语言) + Socket

绝地灬酷狼 2023-01-22 09:51 15阅读 0赞

pthread多线程(C语言) + Socket

pthread是使用使用C语言编写的多线程的API， 简称Pthreads ，是线程的POSIX标准，可以在Unix / Linux / Windows 等系统跨平台使用。在类Unix操作系统(Unix、Linux、Mac OS X等)中，都使用Pthreads作为操作系统的线程。

GitHub项目FanSocket(纯C语言socket+线程队列)+其他demo客户端

1.线程创建

//子线程1

void test1(int \*a)\{

printf("线程test1");

//修改自己的子线程系统释放，注释打开后，线程不能用pthread\_join方法

//pthread\_detach(pthread\_self());

//子线程2

void test2(int \*a)\{

printf("线程test2");

/\*

int pthread\_create(pthread\_t \* thread, //新线程标识符

pthread\_attr\_t \* attr, //新线程的运行属性

void \* (\*start\_routine)(void \*), //线程将会执行的函数

void \* arg);//执行函数的传入参数，可以为结构体

\*/

//创建线程方法一 (手动释放线程)

int a=10;

pthread\_t pid;

pthread\_create(&pid, NULL, (void \*)test1, (void \*)&a);

//线程退出或返回时，才执行回调，可以释放线程占用的堆栈资源(有串行的作用)

if(pthread\_join(pid, NULL)==0)\{

//线程执行完成

printf("线程执行完成：%d\\n",threadIndex);

if (message!=NULL) \{

printf("线程执行完成了\\n");

//创建线程方法二 (自动释放线程)

//设置线程属性

pthread\_attr\_t attr;

pthread\_attr\_init (&attr);

//线程默认是PTHREAD\_CREATE\_JOINABLE，需要pthread\_join来释放线程的

pthread\_attr\_setdetachstate(&attr, PTHREAD\_CREATE\_DETACHED);

//线程并发

int rc=pthread\_create(&pid, &attr, (void \*)test2, (void \*)a);

pthread\_attr\_destroy (&attr);

if (rc!=0) \{

printf("创建线程失败\\n");

return;

2.线程退出和其他

pthread\_exit (tes1) //退出当前线程

pthread\_main\_np () // 获取主线程

//主线程和子线程

if(pthread\_main\_np())\{

//main thread

\}else\{

//others thread

int pthread\_cancel(pthread\_t thread)；//发送终止信号给thread线程,如果成功则返回0

int pthread\_setcancelstate(int state, int \*oldstate)；//设置本线程对Cancel信号的反应

int pthread\_setcanceltype(int type, int \*oldtype)；//设置本线程取消动作的执行时机

void pthread\_testcancel(void)；//检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回

3 线程互斥锁(量)与条件变量

3.1 互斥锁(量)

//静态创建

pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;

//动态创建

int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t \*mutexattr);

//注销互斥锁

int pthread\_mutex\_destroy(pthread\_mutex\_t \*mutex);

//lock 和unlock要成对出现，不然会出现死锁

int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);

int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);

//判断是否可以加锁，如果可以加锁并返回0，否则返回非0

int pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);

3.2 条件变量

条件变量是利用线程间共享的全局变量进行同步的一种机制，

一个线程等待”条件变量的条件成立”而挂起；

另一个线程使”条件成立”(给出条件成立信号)。

为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

//静态创建

pthread\_cond\_t cond=PTHREAD\_COND\_INITIALIZER;

//动态创建

int pthread\_cond\_init(pthread\_cond\_t \*cond, pthread\_condattr\_t \*cond\_attr);

//注销条件变量

int pthread\_cond\_destroy(pthread\_cond\_t \*cond);

//条件等待，和超时等待

int pthread\_cond\_wait(pthread\_cond\_t \*cond, pthread\_mutex\_t \*mutex);

int pthread\_cond\_timedwait(pthread\_cond\_t \*cond, pthread\_mutex\_t \*mutex,

const struct timespec \*abstime);

//开启条件，启动所有等待线程

int pthread\_cond\_broadcast(pthread\_cond\_t \*cond);

//开启一个等待信号量

int pthread\_cond\_signal(pthread\_cond\_t \*cond);

4.线程同步：互斥锁(量)与条件变量(具体封装实现)

/\*全局的队列互斥条件\*/

extern pthread\_cond\_t fan\_cond;

extern pthread\_cond\_t fan\_cond\_wait;

/\*全局的队列互斥锁\*/

extern pthread\_mutex\_t fan\_mutex;

//extern pthread\_mutex\_t fan\_mutex\_wait;

extern int fan\_thread\_status;//0=等待 1=执行 -1=清空所有

extern int fan\_thread\_clean\_status;//0=默认 1=清空所有

//开启线程等待 return=-2一定要处理

extern int fan\_thread\_start\_wait(void);

//正常的超时后继续打开下一个信号量 return=-2一定要处理

int fan\_thread\_start\_timedwait(int sec);

//启动线程，启动信号量

extern int fan\_thread\_start\_signal(void);

//启动等待信号量

extern int fan\_thread\_start\_signal\_wait(void);

//暂停线程

extern int fan\_thread\_end\_signal(void);

//初始化互斥锁

extern int fan\_thread\_queue\_init(void);

//释放互斥锁信号量

extern int fan\_thread\_free(void);

//让队列里面全部执行完毕，而不是关闭线程；

extern int fan\_thread\_clean\_queue(void);

//每次关闭清空后，等待1-2秒，要恢复状态，不然线程添加

extern int fan\_thread\_init\_queue(void);

//设置线程的优先级，必须在子线程

extern int fan\_thread\_setpriority(int priority);

线程队列互斥，并且按入队顺序，一个一个按照外部条件，触发信号量，主要是等待队列，

/\*全局的队列互斥条件\*/

pthread\_cond\_t fan\_cond=PTHREAD\_COND\_INITIALIZER;

pthread\_cond\_t fan\_cond\_wait=PTHREAD\_COND\_INITIALIZER;

/\*全局的队列互斥锁\*/

pthread\_mutex\_t fan\_mutex = PTHREAD\_MUTEX\_INITIALIZER;

//pthread\_mutex\_t fan\_mutex\_wait = PTHREAD\_MUTEX\_INITIALIZER;

int fan\_thread\_status=1;//0=等待 1=执行

int fan\_thread\_clean\_status;//0=默认 1=清空所有

//开启线程等待

int fan\_thread\_start\_wait(void)\{

pthread\_mutex\_lock(&fan\_mutex);

fan\_thread\_clean\_status=0;

while (fan\_thread\_status==0) \{

pthread\_cond\_wait(&fan\_cond, &fan\_mutex);

if (fan\_thread\_clean\_status==1) \{

break;

if (fan\_thread\_clean\_status==1) \{

pthread\_mutex\_unlock(&fan\_mutex);

return -2;

if (fan\_thread\_status==1) \{

fan\_thread\_status=0;

pthread\_mutex\_unlock(&fan\_mutex);

\}else\{

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//正常的超时后继续打开下一个信号量

int fan\_thread\_start\_timedwait(int sec)\{

int rt=0;

pthread\_mutex\_lock(&fan\_mutex);

struct timeval now;

struct timespec outtime;

gettimeofday(&now, NULL);

outtime.tv\_sec = now.tv\_sec + sec;

outtime.tv\_nsec = now.tv\_usec \* 1000;

int result = pthread\_cond\_timedwait(&fan\_cond\_wait, &fan\_mutex, &outtime);

if (result!=0) \{

//线程等待超时

rt=-1;

if (fan\_thread\_clean\_status==1) \{

rt = -2;

pthread\_mutex\_unlock(&fan\_mutex);

return rt;

//启动线程，启动信号量

int fan\_thread\_start\_signal(void)\{

int rs=pthread\_mutex\_trylock(&fan\_mutex);

if(rs!=0)\{

pthread\_mutex\_unlock(&fan\_mutex);

fan\_thread\_status=1;

pthread\_cond\_signal(&fan\_cond);

// pthread\_cond\_broadcast(&fan\_cond);//全部线程

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//开启等待时间的互斥信号量

int fan\_thread\_start\_signal\_wait(void)\{

int rs=pthread\_mutex\_trylock(&fan\_mutex);

if(rs!=0)\{

pthread\_mutex\_unlock(&fan\_mutex);

// fan\_thread\_status=1;

pthread\_cond\_signal(&fan\_cond\_wait);

// pthread\_cond\_broadcast(&fan\_cond);//全部线程

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//暂停下一个线程

int fan\_thread\_end\_signal(void)\{

pthread\_mutex\_lock(&fan\_mutex);

fan\_thread\_status=0;

pthread\_cond\_signal(&fan\_cond);

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//初始化互斥锁(动态创建)

int fan\_thread\_queue\_init(void)\{

pthread\_mutex\_init(&fan\_mutex, NULL);

pthread\_cond\_init(&fan\_cond, NULL);

return 0;

//释放互斥锁和信号量

int fan\_thread\_free(void)

pthread\_mutex\_destroy(&fan\_mutex);

pthread\_cond\_destroy(&fan\_cond);

return 0;

//清空所有的队列

int fan\_thread\_clean\_queue(void)\{

pthread\_mutex\_lock(&fan\_mutex);

fan\_thread\_clean\_status=1;

pthread\_cond\_broadcast(&fan\_cond);

pthread\_cond\_broadcast(&fan\_cond\_wait);

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//恢复队列

int fan\_thread\_init\_queue(void)\{

pthread\_mutex\_lock(&fan\_mutex);

fan\_thread\_clean\_status=0;

fan\_thread\_status=1;

pthread\_cond\_signal(&fan\_cond);

pthread\_mutex\_unlock(&fan\_mutex);

return 0;

//设置线程的优先级，必须在子线程

int fan\_thread\_setpriority(int priority)\{

struct sched\_param sched;

bzero((void\*)&sched, sizeof(sched));

// const int priority1 = (sched\_get\_priority\_max(SCHED\_RR) + sched\_get\_priority\_min(SCHED\_RR)) / 2;

sched.sched\_priority=priority;

//SCHED\_OTHER(正常,非实时)SCHED\_FIFO(实时，先进先出)SCHED\_RR(实时、轮转法)

pthread\_setschedparam(pthread\_self(), SCHED\_RR, &sched);

return 0;

5 其他线程方法

//return=0:线程存活。ESRCH：线程不存在。EINVAL：信号不合法。

int kill\_ret=pthread\_kill(pid, 0);//测试线程是否存在

printf("线程状态：%d\\n",kill\_ret);

if(kill\_ret==0)\{

//关闭线程

pthread\_cancel(pid);

pthread\_equal(pid, pid1);//比较两个线程ID是否相同

//函数执行一次

pthread\_once\_t once = PTHREAD\_ONCE\_INIT;

pthread\_once(&once, test1);

c语言多线程的作用是什么,pthread多线程(C语言) + Socket

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 C 语言多线程编程

相关 c语言线程Pthread讲解

相关 C语言-多线程

相关 c语言多线程的作用是什么,pthread多线程(C语言) + Socket

相关 c语言多线程是什么东西,如何用C语言实现多线程

相关 c语言多线程代码,如何用C语言实现多线程

相关 c语言多线程调试,C语言多线程目录操作

相关 c语言多线程 11,如何用C语言实现多线程

相关 C语言多线程

相关 C语言多线程