C语言如何在线程间实现同步和互斥

线程之间的同步和互斥解决的问题是线程对共同资源进行访问。Posix有两种方式：

信号量和互斥锁；信号量适用同时可用的资源为多个的情况；互斥锁适用于线程可用的资源只有一个的情况

1、互高段斥锁：互斥锁是用加锁的方式来控制对公共资源的原子 *** 作(一旦开始进行就不会被打断的 *** 作)

互斥锁只有上锁和解锁两种状态。互斥锁可以看作是特殊意义的全局变量，因为在同一时刻只有一个线程能够对互斥锁进行 *** 作；只有上锁的进程才可以对公共资源进行访问，其他进程只能等到该进程解锁才可以对公共资源进行 *** 作。

互斥锁 *** 作函数：

pthread_mutex_init()//初始化

pthread_mutex_lock()//上锁参数：pthread_mutex_t *mutex

pthread_mutex_trylock()//判断上锁 参数：pthread_mutex_t *mutex

pthread_mutex_unlock()//解锁参数：pthread_mutex_t *mutex

pthread_mutex_release()//消除互斥锁 参数：pthread_mutex_t *mutex

互斥锁分为快速互歼扮斥锁、递归互斥锁、检错互斥锁；在 init 的时候确定

int pthread_mutex_t(pthread_mutex_t *mutex, const pthread_mutex_t mutexattr)

第一个参数：进行 *** 作的锁

mutexattr：锁的类型，默认快速互斥锁（阻塞）123456789

2、信号量：信号量本质上是一个计数器，在 *** 作系统做用于PV原子 *** 作；

P *** 作使计数器－1；V *** 作使计数器+1.

在互斥 *** 作中可以是使用一个信号量；在同步 *** 作中需要使用多个信号量，并设置不同的初始值安排它们顺序执行

sem_init() // 初始化 *** 作

sem_wait() // P *** 作，计数器减一；阻塞参数：sem_t *sem

sem_trywait() // P *** 作，计数器减一；非阻塞 参数：sem_t *sem

sem_post()// V *** 作，计数器加一戚改誉 参数：sem_t *sem

sem_destroy() // 销毁信号量参数：sem_t *sem

sem_init(sem_t *sem, int pshared, int value)

pshared用于指定多少个进程共享；value初始值

#include "stdio.h"

#include "stdlib.h"

#include "string.h"

struct PCB {

char NAME[10] /*进程名*/

int ROUND /*进程轮转时间片*/

int REACHTIME /*进程到达时间*/

int CPUTIME /*进程占用CPU时间*/

int COUNT /*计数器*/

int NEEDTIME /*进程完成还要的CPU时间*/

char STATE /*进程的状态*/

struct PCB *NEXT /*链指针*/

}

struct LINK { /*PCB的链结构*/

struct PCB *RUN /*当前运行进程指针*/

struct PCB *READY /*就绪队列头指针*/

struct PCB *TAIL /*就绪队碧姿列尾指针*/

struct PCB *FINISH /*完成队列头指针*/

}

void INIT(LINK *) /*对PCB的链结构初始化*/

void INSERT(LINK *) /*将执行了一个单位时间片数且还未完成的进程的PCB插到就绪队列的队尾*/

void FIRSTIN(LINK *) /*将就绪队列中的第一个进程投入运行*/

void PRINT(LINK *) /*打印每执行一个时间片后的所有空慧带进程的状态*/

void PR(PCB *) /*打印一个进程的状态*/

int CREATE(LINK *,int) 斗芦/*创建新的进程*/

void ROUNDSCH(LINK *) /*按时间片轮转法调度进程*/

void main() {

LINK pcbs

int i

INIT(&pcbs)

i=0

printf("创建5个进程\n\n")

while(i<5) {

if(CREATE(&pcbs,i+1)==1) {

printf("进程已创建\n\n")

i++

}

else

printf("进程创建失败\n\n")

}

FIRSTIN(&pcbs)

ROUNDSCH(&pcbs)

}

void ROUNDSCH(LINK *p) {

PCB *pcb

while(p->RUN!=NULL) {

pcb=(PCB *)malloc(sizeof(PCB))

strcpy(pcb->NAME,p->RUN->NAME)

pcb->ROUND=p->RUN->ROUND

pcb->REACHTIME=p->RUN->REACHTIME

pcb->CPUTIME=p->RUN->CPUTIME

pcb->COUNT=p->RUN->COUNT

pcb->NEEDTIME=p->RUN->NEEDTIME

pcb->STATE=p->RUN->STATE

pcb->NEXT=p->RUN->NEXT

pcb->CPUTIME++

pcb->NEEDTIME--

pcb->COUNT++

if(pcb->NEEDTIME==0) {

pcb->NEXT=p->FINISH->NEXT

p->FINISH->NEXT=pcb

pcb->STATE='F'

p->RUN=NULL

if(p->READY!=p->TAIL)

FIRSTIN(p)

}

else {

p->RUN=pcb

if(pcb->COUNT==pcb->ROUND) {

pcb->COUNT=0

if(p->READY!=p->TAIL) {

pcb->STATE='W'

INSERT(p)

FIRSTIN(p)

}

}

}

PRINT(p)

}

}

void INIT(LINK *p) {

p->RUN=NULL

p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB))

p->READY->NEXT=NULL

p->FINISH=(PCB *)malloc(sizeof(PCB))

p->FINISH->NEXT=NULL

}

int CREATE(LINK *p,int n) {

PCB *pcb,*q

pcb=(PCB *)malloc(sizeof(PCB))

flushall()

printf("请输入第%d个进程的名称：\n",n)

gets(pcb->NAME)

printf("请输入第%d个进程的轮转时间片数：\n",n)

scanf("%d",&(pcb->ROUND))

printf("请输入第%d个进程的到达时间：\n",n)

scanf("%d",&(pcb->REACHTIME))

pcb->CPUTIME=0

pcb->COUNT=0

printf("请输入第%d个进程需运行的时间片数：\n",n)

scanf("%d",&(pcb->NEEDTIME))

pcb->STATE='W'

pcb->NEXT=NULL

if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*输入错误*/

return 0

q=p->READY

while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)

q=q->NEXT

pcb->NEXT=q->NEXT

q->NEXT=pcb

if(pcb->NEXT==NULL)

p->TAIL=pcb

return 1

}

void FIRSTIN(LINK *p) {

PCB *q

q=p->READY->NEXT

p->READY->NEXT=q->NEXT

q->NEXT=NULL

if(p->READY->NEXT==NULL)

p->TAIL=p->READY

q->STATE='R'

p->RUN=q

}

void INSERT(LINK *p) {

PCB *pcb

pcb=(PCB *)malloc(sizeof(PCB))

strcpy(pcb->NAME,p->RUN->NAME)

pcb->ROUND=p->RUN->ROUND

pcb->REACHTIME=p->RUN->REACHTIME

pcb->CPUTIME=p->RUN->CPUTIME

pcb->COUNT=p->RUN->COUNT

pcb->NEEDTIME=p->RUN->NEEDTIME

pcb->STATE=p->RUN->STATE

pcb->NEXT=p->RUN->NEXT

p->TAIL->NEXT=pcb

p->TAIL=pcb

p->RUN=NULL

pcb->STATE='W'

}

void PRINT(LINK *p) {

PCB *pcb

printf("执行一个时间片后的所有进程的状态：\n\n")

if(p->RUN!=NULL)

PR(p->RUN)

if(p->READY!=p->TAIL) {

pcb=p->READY->NEXT

while(pcb!=NULL) {

PR(pcb)

pcb=pcb->NEXT

}

}

pcb=p->FINISH->NEXT

while(pcb!=NULL) {

PR(pcb)

pcb=pcb->NEXT

}

}

void PR(PCB *p) {

printf("进程名：%s\n",p->NAME)

printf("进程轮转时间片：%d\n",p->ROUND)

printf("进程到达时间：%d\n",p->REACHTIME)

printf("进程占用CPU时间：%d\n",p->CPUTIME)

printf("计数器：%d\n",p->COUNT)

printf("进程完成还要的CPU时间：%d\n",p->NEEDTIME)

printf("进程的状态：%c\n\n",p->STATE)

}

---