强烈要求大家都来讨论！如何解决解决哲学家吃饭问题

发表于 2011-3-28 10:42

:lol

发表于 2011-3-28 10:56

101L概括的好！

任何事物都不能说绝对，但是相对的平等是有的
就像数学的求极限，只能无限接近极限，而达不到极限值

其实两派人都对，刘前辈认为无限接近极限，另外一派认为不到极限还不算极限

但是人们追求的都是平等的最大化，绝对的平等是不可能的

就题目来讲能实施的平等都是相对的，只能无限接近，而不能完全相等

123jj · 发表于 2011-3-28 22:53

怎么说呢，几个都不发言我还是忍不住要说两句
101楼和下面的帖子都有捣糨糊的意思，具体咱也不说了
实际的很简单，几个需求向同一个资源做请求，而那个资源不可能同时响应那么多请求的时候
一种就是真正的随机响应，依次来满足各种需求
另外的就做出优先序列（不管你编程的时候有意而为，还是无心插柳），有优先级或者先查到的先响应，那是必然的
至于有人担心饿死，那是很难得的，就像几个同等级的人，要求同一个资源一样
有人来讨论是好事情，就怕没人搭理你
编程这件事说白了就是做到你想达到的目标
数学和其他学科的高级问题在这里同样得不到解答，能解答的要么不屑与和我们这些人为伍讨论，要么同样和我们一样无法解决这些问题
希望看帖子的人多想想O(∩_∩)O~
我都是竹筒子倒水，一下通了
谈得不透，希望拍砖

123jj · 发表于 2011-3-29 00:14

顶 aihe.

哲学家就餐问题是一个基础问题，并非难题。一个普通本科生应该能够解决，更何况像楼主这样能够自己写出 os 的高手。在我给出的连接里，已有几种方式，写出相应的程序，对于楼主，highgear, aihe, 123jj等并非难事。我做出那个 c# 程序，没有超过 10 分钟，也没有参考任何他人的程序。

我不清楚为何这个刘钱被把一个简单的资源共享冲突问题，翻来覆去叽叽歪歪的胡扯一通，可以肯定的是，刘钱被没有做过/解决过 multi thread 之类的资源共享冲突之类的问题，这点不管刘钱被的授课老师是谁，刘钱被应该承认吧？

如果还有人不明白哲学家就餐问题的解答，可以仔细的思考我给出的维基百科连接里的内容，如还是不能明白，可以新开一贴，我可以发一些程序来讨论。

发表于 2011-3-29 08:07

顶LS两位老师，俺老菜打酱油捡菜路过，收下学习了~~~

俺从没学过os, 更不知multi thread 之类的为何物，C不懂，keil则略为了解一点，但还是能判断是非的。

一般情况下，俺判断一个人的能力比较准确，比如，二姨家大名顶顶的运放之皇，曾经给俺出过一道题：

using只能代表编译器指令，不能代表是51呀，谁能保证自己把所有单片机和编译器都用过，using唯一代表51呢？

那我来打打擂呢，LDCF这条指令好啊！汇编还带参呢！

这是哪个机型的？ ...
NE5532 发表于 2011-2-9 17:08

俺一眼就判断出

NE5532老师博学多才，敬佩！

LDCF这条指令俺印象中是东芝16位机TMP93CS40/41的指令，国内应用于税控器比较多，NE5532老师是搞税控系统的？万分敬佩！有机会得向您好好讨教讨教。 ...
123jj 发表于 2011-2-9 18:20

刘前辈刘大师的keil, C, ASM都玩的比较转，比俺强百倍，就是有一点俺始终不明白，刘前辈刘大师软件玩的非常转，只是从发贴回贴中可以看出，硬件不是不懂，连最基本的51核运行机理都一巧不通。在软硬件方面，人有所长，有些人偏硬有些人偏软，人的两个脚都有长短，这都能理解。但是，像刘前辈刘大师这样，独脚闯江湖走世界的，确定少见，很多问题不是刘前辈刘大师的软件基础不好，刘前辈刘大师的软件比俺强百倍以上，只是其硬件的基本知识一点点都没有，拉了其后腿，让人可惜~~~

发表于 2011-3-29 14:54

如此说来有一个哲学家不是永远都吃不到饭?那么就等于4个哲学家吃饭了?

发表于 2011-3-29 16:49

不知道楼上的从哪里推导出来这样结论的

刘前辈 · 发表于 2011-3-29 23:25

把一些胡扯的地方去掉，还是能有些启发的。
最大的启发是：认真看看人家的回帖，站在对方的角度去思考问题，想一想对方为什么这么说。
最前提的条件，如并发、平等、异步都没有统一，然后就开始谈过程，谈解决，谈结果，想想都不肯能。
整个过程就吵在并发，平等的问题上。

发表于 2011-3-30 10:17

LS是高手！

总结的不错，赞一个~~~

发表于 2011-3-30 22:04

本帖最后由 highgear 于 2011-3-30 22:10 编辑

111 楼有道理。这个刘工（冷漠）一遇到他们自认拿手的题目比如以前的led 显示，按键，现在的os, 总是像打了**血一样兴奋。贫乏的知识，脆弱的基础，不是靠一两本外国书所能弥补的。

这个讨论已经变得无聊了，不过我还是再发一个程序。

这次没有用互斥锁 (lock) 来锁住临界区（Critical Section），而是用了线程同步，引入了一个仲裁者 Waiter 来管理 Forks。每个哲学家不能像前一个程序那样自己拿放fork，而是设置一个信号 hungry, 等待 waiter 准备好 fork。 Waiter 使用了最简单的 polling 轮询方式。

这种方式在我前面的 wiki 连接里叙述过，优点是共享资源由仲裁者而不是使用者管理分配，可以完全避免死锁。

复制

 

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading;

 

namespace Philosopher

{

         enum PhilosopherState { Thinking, Hungry, Ready, Unavailable, Eating, Done, };

         class Fork

         {

                   bool _Owned = false;

                   public Fork() { }

                   public bool Owned

                   {

                            get { return _Owned; }

                            set { _Owned = value; }

                   }

         }

 

         class Waiter

         {

                   Thread ServeThread;

                   Philosopher[] Philosphers;

                   bool ThreadRunning;

 

                   public Waiter(Philosopher[] phs) 

                   { 

                            Philosphers = phs;

                            ServeThread = new Thread(StartService);

                            ServeThread.Start();

                   }

                   public void Stop() { ThreadRunning = false; }

 

                   void StartService()

                   {

                            ThreadRunning = true;

                            int i = 0;

                            while (ThreadRunning) {     //轮询

                                     if (Philosphers[i].State == PhilosopherState.Hungry) {   //哲学家饿了

                                               if (!Philosphers[i].Left.Owned  && !Philosphers[i].Right.Owned) {    

                                                        Philosphers[i].Left.Owned = true;     

                                                        Philosphers[i].Right.Owned = true;

                                                        Philosphers[i].State = PhilosopherState.Ready;    //通知哲学家可以就餐

                                               }

                                               else {

                                                        Philosphers[i].State = PhilosopherState.Unavailable;    //没有足够资源

                                               }

                                               Philosphers[i].WaitEvent.Set();     //哲学家结束等待

                                     }

                                     else if (Philosphers[i].State == PhilosopherState.Done) {    //哲学家吃饱了

                                               Philosphers[i].Left.Owned = false;     //回收

                                               Philosphers[i].Right.Owned = false;

                                               Philosphers[i].WaitEvent.Set();

                                     }

                                     i = (i + 1) % Philosphers.Length;     //下一个哲学家

                                     Thread.Sleep(20);

                            }

                   }

         }

发表于 2011-3-30 22:07

class Philosopher
{
int ID;
Thread DiningThread;
bool ThreadRunning;
public AutoResetEvent WaitEvent = new AutoResetEvent(false);
public PhilosopherState State = PhilosopherState.Thinking;
public Fork Left;
public Fork Right;

public Philosopher(int id, Fork left, Fork right) {
ID = id;
Left = left;
Right = right;
DiningThread = new Thread(StartDining);
DiningThread.Start();
}
public void Think() { State = PhilosopherState.Thinking;  Thread.Sleep(1000); }

public void Dine()
{
State = PhilosopherState.Hungry;    //设置 hungry 信号
WaitEvent.WaitOne(1000);                //等待 waiter 服务， 1000ms 超时时间。
if (State == PhilosopherState.Ready) {    //拿到资源
State = PhilosopherState.Eating;
Console.WriteLine("Philosopher " + ID.ToString() + " is dining.");
Thread.Sleep(1000);
State = PhilosopherState.Done;
WaitEvent.WaitOne(1000);    //等待clean, 回收资源
}
}

public void Stop() { ThreadRunning = false; }
void StartDining()
{
ThreadRunning = true;
while (ThreadRunning) {
Think();
Dine();
}
}
}

class Program
{
static void Main(string[] args)
{
Fork[] forks = new Fork[] { new Fork(), new Fork(), new Fork(), new Fork(), new Fork() };
Philosopher[] philosophers = new Philosopher[5];
for (int i = 0; i < 5; i++) {
philosophers[i] = new Philosopher(i, forks[i], forks[(i + 4) % 5]);
}
Waiter waiter = new Waiter(philosophers);
Console.Read();

waiter.Stop();
for (int i = 0; i < 5; i++)
philosophers[i].Stop();
}
}
}

发表于 2011-3-30 22:08

class Philosopher
{
int ID;
Thread DiningThread;
bool ThreadRunning;
public AutoResetEvent WaitEvent = new AutoResetEvent(false);
public PhilosopherState State = PhilosopherState.Thinking;
public Fork Left;
public Fork Right;

public Philosopher(int id, Fork left, Fork right) {
ID = id;
Left = left;
Right = right;
DiningThread = new Thread(StartDining);
DiningThread.Start();
}
public void Think() { State = PhilosopherState.Thinking;  Thread.Sleep(1000); }

public void Dine()
{
State = PhilosopherState.Hungry;    //设置 hungry 信号
WaitEvent.WaitOne(1000);                //等待 waiter 服务， 1000ms 超时时间。
if (State == PhilosopherState.Ready) {    //拿到资源
State = PhilosopherState.Eating;
Console.WriteLine("Philosopher " + ID.ToString() + " is dining.");
Thread.Sleep(1000);
State = PhilosopherState.Done;
WaitEvent.WaitOne(1000);    //等待clean, 回收资源
}
}

public void Stop() { ThreadRunning = false; }
void StartDining()
{
ThreadRunning = true;
while (ThreadRunning) {
Think();
Dine();
}
}
}

class Program
{
static void Main(string[] args)
{
Fork[] forks = new Fork[] { new Fork(), new Fork(), new Fork(), new Fork(), new Fork() };
Philosopher[] philosophers = new Philosopher[5];
for (int i = 0; i < 5; i++) {
philosophers[i] = new Philosopher(i, forks[i], forks[(i + 4) % 5]);
}
Waiter waiter = new Waiter(philosophers);
Console.Read();

waiter.Stop();
for (int i = 0; i < 5; i++)
philosophers[i].Stop();
}
}
}

发表于 2011-4-1 06:11

好程序！学习了

发表于 2011-4-9 16:39

虽然有些地方看不懂，但整体可以理解

发表于 2011-4-9 16:43

还有没有说更精确的讲解？

发表于 2011-4-12 22:27

tongyi

发表于 2011-4-30 10:34

做个记号，以后再看

发表于 2011-4-30 10:38

做个记号，以后再看看

发表于 2011-5-4 20:40

很有意思...还在学习c中

发表于 2011-5-7 10:23

mark

强烈要求大家都来讨论！如何解决解决哲学家吃饭问题

评分

评分

评分

浏览过的版块

社区建设奖章

欢快之小溪

伴坛终老

技术高手奖章

技术奇才奖章

涓涓之细流

核心会员奖章

七世轮回

坚毅之洋流

湍急之河流

缘定三生

技术导师奖章

无冕之王奖章

十世金身

沉静之湖泊

甘甜之泉水

常驻人口