Qt之哲学家问题（linux 多线程）

转载请注明出处：http://blog.csdn.net/feng1790291543

linux多线程实现哲学家问题，根据哲学家吃饭、拿筷子、放下筷子......

首先，主线程使用Qt下的GUI的简单一个按钮控制就行了

maindesttop.cpp

#include "maindesttop.h"
#include "ui_maindesttop.h"

QMutex mutex01;
QMutex mutex02;
QMutex mutex03;
QMutex mutex04;
QMutex mutex05;

int n1=1;
int n2=1;
int n3=1;
int n4=1;
int n5=1;

QWaitCondition waitcondition001;
QWaitCondition waitcondition002;
QWaitCondition waitcondition003;
QWaitCondition waitcondition004;
QWaitCondition waitcondition005;

MainDestTop::MainDestTop(QWidget *parent)
        : QWidget(parent), ui(new Ui::MainDestTop)
{
    ui->setupUi(this);
}

MainDestTop::~MainDestTop()
{
    delete ui;
}

void MainDestTop::on_pushButtonStart_clicked()
{
    pro001=new Proferssor001;
    pro002=new Professor002;
    pro003=new Professor003;
    pro004=new Professor004;
    pro005=new Professor005;

    pro001->start();
    pro002->start();
    pro003->start();
    pro004->start();
    pro005->start();

    return ;
}

void MainDestTop::StopThread()
{
    pro001->quit();
    pro001->wait();
    pro001->deleteLater();
    delete pro001;
    pro001=NULL;

    pro002->quit();
    pro002->wait();
    pro002->deleteLater();
    delete pro002;
    pro002=NULL;

    pro003->quit();
    pro003->wait();
    pro003->deleteLater();
    delete pro003;
    pro003=NULL;

    pro004->quit();
    pro004->wait();
    pro004->deleteLater();
    delete pro004;
    pro004=NULL;

    pro005- >quit();
    pro005->wait();
    pro005->deleteLater();
    delete pro005;
    pro005=NULL;
}

maindesttop.h

#ifndef MAINDESTTOP_H
#define MAINDESTTOP_H

#include <QtGui/QWidget>
#include <QtCore>
#include <QMutex>
#include "proferssor001.h"
#include "professor002.h"
#include "professor003.h"
#include "professor004.h"
#include "professor005.h"

namespace Ui
{
    class MainDestTop;
}

class MainDestTop : public QWidget
{
    Q_OBJECT

public:
    MainDestTop(QWidget *parent = 0);
    ~MainDestTop();
    void StopThread();

private:
    Ui::MainDestTop *ui;

    Proferssor001 *pro001;
    Professor002 *pro002;
    Professor003 *pro003;
    Professor004 *pro004;
    Professor005 *pro005;

private slots:
    void on_pushButtonStart_clicked();
};

#endif // MAINDESTTOP_H

其次，子线程源码如下：

#ifndef PROFERSSOR001_H
#define PROFERSSOR001_H

#include <QThread>
#include <QtCore>

class Proferssor001 : public QThread
{
public:
    Proferssor001();
    void run();
};

#endif // PROFERSSOR001_H

第一个线程源码：

#include "proferssor001.h"

/****************
  proferssor001---->A  proferssor002---->B   proferssor003--->C   proferssor004---->D   proferssor005---->E

 资源夺取: A--->1/5    B--->2/1     C--->3/2     D--->4/3       E--->5/4

******************/
extern QMutex mutex01;
extern QMutex mutex02;
extern QMutex mutex03;
extern QMutex mutex04;
extern QMutex mutex05;

extern int n1;
extern int n2;
extern int n3;
extern int n4;
extern int n5;

extern QWaitCondition waitcondition001;
extern QWaitCondition waitcondition002;
extern QWaitCondition waitcondition003;
extern QWaitCondition waitcondition004;
extern QWaitCondition waitcondition005;

Proferssor001::Proferssor001()
{
}

void Proferssor001::run()
{
    while(1)
    {
        mutex01.lock();
        mutex05.lock();
        while((n1+n5)<2)
        {
            mutex05.unlock();
            qDebug()<<"proferssor001哲学家没左边筷子~";
            mutex01.unlock();
            qDebug()<<"proferssor001哲学家没右边筷子~";

            qDebug()<<"proferssor001$$$$$$$$$$哲学家开始休息....";
            waitcondition001.wait(&mutex01);
            waitcondition005.wait(&mutex05);
            continue ;
        }
        qDebug()<<"proferssor001$$$$$$$$$$哲学家开始吃饭~";
        n1--;
        n5--;
        mutex05.unlock();
        n5=(n5+1);
        qDebug()<<"proferssor001$$$$$$$$$$哲学家放下左边筷子~";
        msleep(2);
        mutex01.unlock();
        n1=(n1+1);
        qDebug()<<"proferssor001$$$$$$$$$$哲学家放下右边筷子~";
        msleep(2);
    }
    return ;
}

第二线程头文件：

#ifndef PROFESSOR002_H
#define PROFESSOR002_H

#include <QThread>
#include <QtCore>

class Professor002 : public QThread
{
public:
    Professor002();
    void run();
};

#endif // PROFESSOR002_H

源程序：

#include "professor002.h"
/****************
  proferssor001---->A  proferssor002---->B   proferssor003--->C   proferssor004---->D   proferssor005---->E

 资源夺取: A--->1/5    B--->2/1     C--->3/2     D--->4/3       E--->5/4

******************/
extern QMutex mutex01;
extern QMutex mutex02;
extern QMutex mutex03;
extern QMutex mutex04;
extern QMutex mutex05;

extern int n1;
extern int n2;
extern int n3;
extern int n4;
extern int n5;

extern QWaitCondition waitcondition001;
extern QWaitCondition waitcondition002;
extern QWaitCondition waitcondition003;
extern QWaitCondition waitcondition004;
extern QWaitCondition waitcondition005;

Professor002::Professor002()
{
}

void Professor002::run()
{
    while(1)
    {
        mutex02.lock();
        mutex01.lock();
        while((n1+n2)<2)
        {
            mutex01.unlock();
            qDebug()<<"proferssor002哲学家没左边筷子~";
            mutex02.unlock();
            qDebug()<<"proferssor002哲学家没右边筷子~";

            qDebug()<<"proferssor002&&&&&&&&&哲学家开始休息....";
            waitcondition002.wait(&mutex02);
            waitcondition001.wait(&mutex01);
            continue ;
        }
        qDebug()<<"proferssor002&&&&&&&&&哲学家开始吃饭~";
        n1--;
        n2--;
        mutex01.unlock();
        n1=(n1+1);
        qDebug()<<"proferssor002&&&&&&&&&哲学家放下左边筷子~";
        msleep(2);
        mutex02.unlock();
        n2=(n2+1);
        qDebug()<<"proferssor002&&&&&&&&&哲学家放下右边筷子~";
        msleep(2);
    }
    return ;
}

线程三，头文件：

#ifndef PROFESSOR003_H
#define PROFESSOR003_H

#include <QThread>
#include <QtCore>

class Professor003 : public QThread
{
public:
    Professor003();
    void run();
};

#endif // PROFESSOR003_H

源文件：

#include "professor003.h"
/****************
  proferssor001---->A  proferssor002---->B   proferssor003--->C   proferssor004---->D   proferssor005---->E

 资源夺取: A--->1/5    B--->2/1     C--->3/2     D--->4/3       E--->5/4

******************/
extern QMutex mutex01;
extern QMutex mutex02;
extern QMutex mutex03;
extern QMutex mutex04;
extern QMutex mutex05;

extern int n1;
extern int n2;
extern int n3;
extern int n4;
extern int n5;

extern QWaitCondition waitcondition001;
extern QWaitCondition waitcondition002;
extern QWaitCondition waitcondition003;
extern QWaitCondition waitcondition004;
extern QWaitCondition waitcondition005;

Professor003::Professor003()
{
}
void Professor003::run()
{
    while(1)
    {
        mutex03.lock();
        mutex02.lock();
        while((n2+n3)<2)
        {
            mutex02.unlock();
            qDebug()<<"proferssor003哲学家没左边筷子~";
            mutex03.unlock();
            qDebug()<<"proferssor003哲学家没右边筷子~";

            qDebug()<<"proferssor003******哲学家开始休息....";
            waitcondition003.wait(&mutex03);
            waitcondition002.wait(&mutex02);
            continue ;
        }
        qDebug()<<"proferssor003******哲学家开始吃饭~";
        n2--;
        n3--;
        mutex02.unlock();
        n2=(n2+1);
        qDebug()<<"proferssor003******哲学家放下左边筷子~";
        msleep(2);
        mutex03.unlock();
        n3=(n3+1);
        qDebug()<<"proferssor003******哲学家放下右边筷子~";
        msleep(2);
    }
    return ;
}

线程4头文件：

#ifndef PROFESSOR004_H
#define PROFESSOR004_H

#include <QThread>
#include <QtCore>

class Professor004 : public QThread
{
public:
    Professor004();
    void run();
};

#endif // PROFESSOR004_H

源文件：

#include "professor004.h"
/****************
  proferssor001---->A  proferssor002---->B   proferssor003--->C   proferssor004---->D   proferssor005---->E

 资源夺取: A--->1/5    B--->2/1     C--->3/2     D--->4/3       E--->5/4

******************/
extern QMutex mutex01;
extern QMutex mutex02;
extern QMutex mutex03;
extern QMutex mutex04;
extern QMutex mutex05;

extern int n1;
extern int n2;
extern int n3;
extern int n4;
extern int n5;

extern QWaitCondition waitcondition001;
extern QWaitCondition waitcondition002;
extern QWaitCondition waitcondition003;
extern QWaitCondition waitcondition004;
extern QWaitCondition waitcondition005;

Professor004::Professor004()
{
}
void Professor004::run()
{
    while(1)
    {
        mutex04.lock();
        mutex03.lock();
        while((n4+n3)<2)
        {

            mutex03.unlock();
            qDebug()<<"proferssor004哲学家没左边筷子~";
            mutex04.unlock();
            qDebug()<<"proferssor004哲学家没右边筷子~";

            qDebug()<<"proferssor004----哲学家开始休息....";
            waitcondition004.wait(&mutex04);
            waitcondition003.wait(&mutex03);
            continue ;
        }
        qDebug()<<"proferssor004----哲学家开始吃饭~";
        n3--;
        n4--;
        mutex03.unlock();
        n3=(n3+1);
        qDebug()<<"proferssor004----哲学家放下左边筷子~";
        msleep(2);
        mutex04.unlock();
        n4=(n4+1);
        qDebug()<<"proferssor004----哲学家放下右边筷子~";
        msleep(2);
    }
    return ;
}

线程5头文件：

#ifndef PROFESSOR005_H
#define PROFESSOR005_H

#include <QThread>
#include <QtCore>

class Professor005 : public QThread
{
public:
    Professor005();
    void run();
};

#endif // PROFESSOR005_H

源文件：

#include "professor005.h"
/****************
  proferssor001---->A  proferssor002---->B   proferssor003--->C   proferssor004---->D   proferssor005---->E

 资源夺取: A--->1/5    B--->2/1     C--->3/2     D--->4/3       E--->5/4

******************/
extern QMutex mutex01;
extern QMutex mutex02;
extern QMutex mutex03;
extern QMutex mutex04;
extern QMutex mutex05;

extern int n1;
extern int n2;
extern int n3;
extern int n4;
extern int n5;

extern QWaitCondition waitcondition001;
extern QWaitCondition waitcondition002;
extern QWaitCondition waitcondition003;
extern QWaitCondition waitcondition004;
extern QWaitCondition waitcondition005;

Professor005::Professor005()
{
}

void Professor005::run()
{
    while(1)
    {
        mutex05.lock();
        mutex04.lock();
        while((n4+n5)<2)
        {

            mutex04.unlock();
            qDebug()<<"proferssor005哲学家没左边筷子~";
            mutex05.unlock();
            qDebug()<<"proferssor005哲学家没右边筷子~";

            qDebug()<<"proferssor005====哲学家开始休息....";
            waitcondition005.wait(&mutex05);
            waitcondition004.wait(&mutex04);
            continue ;
        }
        qDebug()<<"proferssor005====哲学家开始吃饭~";
        n4--;
        n5--;
        mutex04.unlock();
        n4=(n4+1);
        qDebug()<<"proferssor005====哲学家放下左边筷子~";
        msleep(2);
        mutex05.unlock();
        n5=(n5+1);
        qDebug()<<"proferssor005====哲学家放下右边筷子~";
        msleep(2);
    }
    return ;
}

运行结果：

资源免费下载：http://download.csdn.net/detail/feng1790291543/7324039

Qt之哲学家问题（linux 多线程）

时间： 2024-08-07 12:36:57

Qt之哲学家问题（linux 多线程）的相关文章

【Qt入门实践】Qt之哲学家问题（linux 多线程）

转载请注明出处:http://blog.csdn.net/feng1790291543 linux多线程实现哲学家问题,依据哲学家吃饭.拿筷子.放下筷子...... 首先,主线程使用Qt下的GUI的简单一个button控制即可了 maindesttop.cpp #include "maindesttop.h" #include "ui_maindesttop.h" QMutex mutex01; QMutex mutex02; QMutex mutex03; QMu

《Linux多线程编程手册》读书笔记

第二章 基本线程编程 1.(P25)如果多个线程等待同一个线程终止,则所有等待线程将一直等到目标线程终止.然后,一个等待线程成功返回,其余的等待线程将失败并返回ESRCH错误. 2.(P26)将新线程的pbe参数作为栈参数进行传递.这个线程参数之所以能够作为栈参数传递,是因为主线程会等待辅助线程终止.不过,首选方法是使用malloc从堆分配存储,而不是传递指向线程栈存储的地址.如果将该参数作为地址传递到线程栈存储,则该地址可能无效或者在线程终止时会被重新分配. 3.(P28)pthread_de

qt ui程序使用Linux的文件操作open、close （转）

原文地址:qt ui程序使用Linux的文件操作open.close 作者:kjpioo 提出这个问题是因为在qt的QWidget类型的对象中,close()函数会和QWidget::close()冲突,如果在类函数实现时直接用close(),在程序编译时会提示提示错误(具体什么错误不记得了). 错误原因是QWidget::close()与stdio.h中的文件关闭标准函数close()产生了歧义.所以可以参考下文链接中的解决方案. http://bytes.com/topic/c/answer

linux 多线程信号处理总结

linux 多线程信号总结(一) 1. 在多线程环境下,产生的信号是传递给整个进程的,一般而言,所有线程都有机会收到这个信号,进程在收到信号的的线程上下文执行信号处理函数,具体是哪个线程执行的难以获知.也就是说,信号会随机发个该进程的一个线程. 2 signal函数BSD/Linux的实现并不在信号处理函数调用时,恢复信号的处理为默认,而是在信号处理时阻塞此信号,直到信号处理函数返回.其他实现可能在调用信号处理函数时,恢复信号的处理为默认方式,因而需要在信号处理函数中重建信号处理函数为我们定义的

Linux多线程程序设计------创建线程

1.创建线程 #include<pthread.h> int pthread_create(pthread_t* tidp,const pthread_attr_t *attr,void*(*start_rtn)(void),void*arg) tidp:线程id attr:线程属性(通常为空) start_rtn:线程要执行的函数 arg:start_rtn的参数 Linux多线程程序设计------创建线程,布布扣,bubuko.com

linux多线程示例

1 #include <stdio.h> 2 #include <unistd.h> 3 #include <stdlib.h> 4 #include <pthread.h> 5 6 typedef void* (*fun)(void*); 7 8 fun fun1, fun2; 9 10 pthread_mutex_t pmu = PTHREAD_MUTEX_INITIALIZER; 11 pthread_cond_t cond; 12 pthread_t

Linux多线程与同步

Linux多线程与同步 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 典型的UNIX系统都支持一个进程创建多个线程(thread).在Linux进程基础中提到,Linux以进程为单位组织操作,Linux中的线程也都基于进程.尽管实现方式有异于其它的UNIX系统,但Linux的多线程在逻辑和使用上与真正的多线程并没有差别. 多线程 我们先来看一下什么是多线程.在Linux从程序到进程中,我们看到了一个程序在内存中的表示.这个程

Linux多线程编程-互斥锁

互斥锁 多线程编程中,(多线程编程)可以用互斥锁(也称互斥量)可以用来保护关键代码段,以确保其独占式的访问,这有点像二进制信号量.POSIX互斥锁相关函数主要有以下5个: #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthread_mutex_destroy(pthread_mutex_t *mutex); int p

Linux多线程编程-条件变量

条件变量 如果说线程间的互斥锁是用来同步共享数据的访问的话,那么条件变量是用于线程之间共享数据的值.条件变量提供了一种线程之间的通知机制,当某个共享数据达到某个值时,唤醒等待这个共享数据的线程.条件变量相关函数主要 有5个: #include <pthread.h> int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr); int pthread_cond_destroy(pthread_