c语言避免死锁
‘壹’ 死锁解决c语言程序
#include <windows.h>
#include <iostream>
#include<time.h>
const unsigned short SIZE_OF_BUFFER = 1; //缓冲区长度
int g_buffer[SIZE_OF_BUFFER];
bool g_continue = true; //控制程序结束
HANDLE g_hMutex; //用于线程间的互斥
DWORD WINAPI FatherProc(LPVOID); //父进程线程
DWORD WINAPI SonProc(LPVOID); //使用打印机的线程
int main()
{
//创建各个互斥信号
g_hMutex = CreateMutex(NULL,FALSE,NULL);
const unsigned short FATHERS_COUNTS = 1; //父进程线程的个数
const unsigned short SONS_COUNT = 2; //使用打印机的线程的个数
//总的线程数
const unsigned short THREADS_COUNT = FATHERS_COUNTS+SONS_COUNT;
HANDLE hThreads[THREADS_COUNT]; //各线程的handle
DWORD fatherID[FATHERS_COUNTS]; //父进程线程的标识符
DWORD sonID[SONS_COUNT]; //使用打印机的线程的标识符
//父进程线程
for (int i=0;i<FATHERS_COUNTS;++i){
hThreads[i]=CreateThread(NULL,0,FatherProc,NULL,0,&fatherID[i]);
if (hThreads[i]==NULL) return -1;
}
//使用打印机的线程
for (i=0;i<SONS_COUNT;++i){
hThreads[SONS_COUNT+i]=CreateThread(NULL,0,SonProc,NULL,0,&sonID[i]);
if (hThreads[i]==NULL) return -1;
}
while(g_continue){
if(getchar())
{ //按回车后终止程序运行
g_continue = false;
}
}
return 0;
}
//分配打印机
void Append()
{
srand((unsigned)time(0));
std::cerr << "打印机空闲 ...\n";
if(rand()%2)
{
g_buffer[0]=1;//给PA
}
else
{
g_buffer[0]=0;//给PB
}
}
//son使用打印机
void Take()
{
if(g_buffer[0]==1)
{
std::cerr << "PA使用打印机 ... ";
std::cerr << "成功" << std::endl<<std::endl; ;
};
if(g_buffer[0]==0)
{
std::cerr << "PB使用打印机 ... ";
std::cerr << "成功" << std::endl<<std::endl; ;
};
g_buffer[0]=-1;
}
//父进程
DWORD WINAPI FatherProc(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hMutex,INFINITE);
Append();
Sleep(1500);
ReleaseMutex(g_hMutex);
}
return 0;
}
//子进程
DWORD WINAPI SonProc(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hMutex,INFINITE);
Take();
Sleep(1500);
ReleaseMutex(g_hMutex);
}
return 0;
} 最后的要求自己添加
‘贰’ c语言死锁解除程序，利用寻找上一级标识，不让上级发射变迁到死锁标识，最后输出，如果存在死锁，让父标
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
pthread_mutex_t m;
void *runodd(void *d)
{
int i=0;
for(i=1;;i+=2)
{
pthread_mutex_lock(&m);
printf("奇数：%d\n",i);
usleep(100);
pthread_mutex_unlock(&m);
}
}
void *runeven(void *d)
{
int i=0;
for(i=0;;i+=2)
{
pthread_mutex_lock(&m);
printf("偶数：%d\n",i);
usleep(100);
pthread_mutex_unlock(&m);
}
}
main()
{
pthread_t todd,teven;
pthread_mutex_init(&m,0);
pthread_create(&todd,0,runodd,0);
pthread_create(&teven,0,runeven,0);
sleep(5);
printf("外部强制停止todd线程\n");
pthread_cancel(todd);
pthread_join(todd,(void**)0);
pthread_join(teven,(void**)0);
pthread_mutex_destroy(&m);
}
‘叁’ 求一个在C语言环境下进行死锁检测的程序
#include<stdio.h>
#include<iostream.h>
#include<string.h>
const int MAXQUEUE=100; //定义表的最大行数
typedef struct node{
int resource;
int process;
}cell;
cell occupy[MAXQUEUE];
int occupy_quantity;
cell wait[MAXQUEUE];
int wait_quantity;
//初始化函数
void initial()
{
int i;
for(i=0;i<MAXQUEUE;i++){
occupy.process=-1;
occupy.resource=-1;
wait.process=-1;
wait.resource=-1;
}
occupy_quantity=0;
wait_quantity=0;
}
//读数据文件
int readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"请输入资源分配表文件的文件名:"<<endl;
strcpy(fname,"10trouble1.txt");
//cin>>fname;
if((fp=fopen(fname,"r"))==NULL){
cout<<"错误,文件打不开,请检查文件名:)"<<endl;
return 0;
}
else{
while(!feof(fp)){
fscanf(fp,"%d %d",&occupy[occupy_quantity].resource,&occupy[occupy_quantity].process);
occupy_quantity++;
}
}
cout<<"请输入进程等待表文件的文件名:"<<endl;
strcpy(fname,"10trouble2.txt");
//cin>>fname;
if((fp=fopen(fname,"r"))==NULL){
cout<<"错误,文件打不开,请检查文件名:)"<<endl;
return 0;
}
else{
while(!feof(fp)){
fscanf(fp,"%d %d",&wait[wait_quantity].process,&wait[wait_quantity].resource);
wait_quantity++;
}
}
//输出所读入的数据
cout<<endl<<endl<<"输出所读入的数据"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"资源分配表"<<endl;
cout<<"资源编号 进程编号"<<endl;
for(i=0;i<occupy_quantity;i++){
cout<<" "<<occupy.resource<<" "<<occupy.process<<endl;
}
cout<<"———————————————————————"<<endl;
cout<<"进程等待表"<<endl;
cout<<"进程编号 资源编号"<<endl;
for(i=0;i<wait_quantity;i++){
cout<<" "<<wait.resource<<" "<<wait.process<<endl;
}
return 1;
}
//检测
void check()
{
int table[MAXQUEUE][MAXQUEUE];
int table1[MAXQUEUE][MAXQUEUE];
int i,j,k;
int flag,t,p;
int max_process;
//初始化表格
for(i=0;i<MAXQUEUE;i++){
for(j=0;j<MAXQUEUE;j++){
table[j]=0;
table1[j]=0;
}
}
//先找到进程最大编号
max_process=-1;
for(i=0;i<occupy_quantity;i++){
if(occupy.process>max_process){
max_process=occupy.process;
}
}
for(i=0;i<wait_quantity;i++){
if(wait.process>max_process){
max_process=wait.process;
}
}
for(i=0;i<wait_quantity;i++){
for(j=0;j<occupy_quantity;j++){
if(wait.resource==occupy[j].resource){
table[wait.process][occupy[j].process]=1;
table1[wait.process][occupy[j].process]=1;
}
}
}
cout<<"初始等待占用表:"<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
cout<<table[j]<<" ";
}
cout<<endl;
}
cout<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
for(k=0;k<max_process+1;k++){
table[j]=table[j]||(table[k]&&table[k][j]);
}
}
}
cout<<"检测后的等待占用表:"<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
cout<<table[j]<<" ";
}
cout<<endl;
}
flag=-1;
for(i=0;i<max_process+1;i++){
if(table==1){
flag=i;
break;
}
}
cout<<endl<<endl<<"检测结果"<<endl;
cout<<"———————————————————"<<endl;
if(flag!=-1){
cout<<"存在死锁"<<endl;
cout<<"进程循环等待队列:";
p=flag; //存在进程循环等待队列的那一进程
//进程循环等待队列中的所有进程是table表中的这一行是1的进程,只是顺序要再确定
t=1;
while(t){
cout<<p<<" ";
for(j=0;j<max_process+1;j++){
if(table1[p][j]==1){
if(table[j][flag]==1){
p=j;
break;
}
}
}
if(p==flag)t=0;
}
cout<<flag<<endl;
}
else{
cout<<"不存在死锁"<<endl;
}
}
‘肆’ 用C语言定义一个死锁
楼主是垃圾啊~~
---------------------------------------------
while(1);
for(;;);
死循环算不算死锁?
‘伍’ c语言高手进:什么是"锁死"
一个进程占用了系统的一个资源，但是它同时需要量外一个资源，但是另外一个进程同时占用了了原来的进程需要的资源，而且也在等在系统分配原来的进程占用的资源。这就是死锁
‘陆’ （C语言中）互斥锁的死锁问题
如果你将mutex_c换成mutex_p,则不会死锁,因为,你第一个线程锁上后,切换到第二个线程,因为mutex_p未释放,第二个线程无法获取mutex_p,进入等待状态,此时OS将再次调度第一个线程,直到第一个线程释放mutex_p之后,第二个线程才会被激活,然后调试第二线程,获取mutex_p.
使用OS提供的互斥量来保护公共资源还是比较安全的,但如果用二值信号量的话,就可能会有优先级反转的情况.
‘柒’ C语言实现死锁
如果是java就好了，无能为力呀！
‘捌’ C语言如何避免死循环
管理好你的循环控制变量
使while 的条件有机会为FALSE
或在循环体中加入break，并使它有机会执行。
‘玖’ C语言中避免程序一闪而过的代码intmain(void){…system("pause");见下
一闪而过是程序自动结束，同时编译器没有提供结果驻留功能。对于此种情况，可以手动在代码结尾增加驻留功能的函数。常用的有如下两种：
1 通过getch函数驻留。
getch会等待从屏幕的输入，在main函数退出前，增加
getch();
调用，系统会等待输入，直到有新的输入，才会退出界面。
2 通过system("pause");来实现驻留。
在main退出前调用
system("pause");
会调用系统的pause函数，提示并实现按任意键退出程序效果。
如果是已经编译好的C语言程序，可以通过开始->运行，键入cmd后回车。
在打开的命令行窗口，将可执行文件拖动到窗口上，再回车即可运行该程序，在此窗口不会出现闪退，从而观察运行结果。
由于该问题仅在windows平台出现，所以以上介绍均针对windows平台。
‘拾’ 怎样用C语言描述操作系统里的死锁算法谢谢。
利用银行家算法避免死锁 . 银行家算法 设Requesti是进程Pi的请求向量，如果Requesti〔j〕=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：� (1) 如果Requesti〔j〕≤Need〔i,j〕，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。 (2) 如果Requesti〔j〕≤Available〔j〕，便转向步骤(3)；否则， 表示尚无足够资源，Pi须等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。