打印

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

[复制链接]
楼主: singleywy
手机看帖
扫描二维码
随时随地手机跟帖
101
liuxiang889| | 2011-3-28 10:42 | 只看该作者 回帖奖励 |倒序浏览
:lol

使用特权

评论回复
102
dudu_q| | 2011-3-28 10:56 | 只看该作者
101L概括的好!

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

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

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

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

使用特权

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

使用特权

评论回复
评分
参与人数 2威望 +2 收起 理由
123jj + 1
highgear + 1
104
highgear| | 2011-3-29 00:14 | 只看该作者
顶 aihe.

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

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

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

使用特权

评论回复
评分
参与人数 1威望 +1 收起 理由
123jj + 1
105
123jj| | 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核运行机理都一巧不通。在软硬件方面,人有所长,有些人偏硬有些人偏软,人的两个脚都有长短,这都能理解。但是,像刘前辈刘大师这样,独脚闯江湖走世界的,确定少见,很多问题不是刘前辈刘大师的软件基础不好,刘前辈刘大师的软件比俺强百倍以上,只是其硬件的基本知识一点点都没有,拉了其后腿,让人可惜~~~

使用特权

评论回复
106
sylva0| | 2011-3-29 14:54 | 只看该作者
如此说来有一个哲学家不是永远都吃不到饭?那么就等于4个哲学家吃饭了?

使用特权

评论回复
107
aihe| | 2011-3-29 16:49 | 只看该作者
不知道楼上的从哪里推导出来这样结论的

使用特权

评论回复
108
sysdriver| | 2011-3-29 23:25 | 只看该作者
把一些胡扯的地方去掉,还是能有些启发的。
最大的启发是:认真看看人家的回帖,站在对方的角度去思考问题,想一想对方为什么这么说。
最前提的条件,如并发、平等、异步都没有统一,然后就开始谈过程,谈解决,谈结果,想想都不肯能。
整个过程就吵在并发,平等的问题上。

使用特权

评论回复
评分
参与人数 2威望 +2 收起 理由
刘前辈 + 1
123jj + 1
109
123jj| | 2011-3-30 10:17 | 只看该作者
LS是高手!

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

使用特权

评论回复
110
highgear| | 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);
                            }
                   }
         }



使用特权

评论回复
111
highgear| | 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();
                }
        }
}

使用特权

评论回复
112
highgear| | 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();
                }
        }
}

使用特权

评论回复
113
123jj| | 2011-4-1 06:11 | 只看该作者
好程序!学习了

使用特权

评论回复
114
y49h57| | 2011-4-9 16:39 | 只看该作者
虽然有些地方看不懂,但整体可以理解

使用特权

评论回复
115
y49h57| | 2011-4-9 16:43 | 只看该作者
还有没有说更精确的讲解?

使用特权

评论回复
116
ggfa| | 2011-4-12 22:27 | 只看该作者
tongyi

使用特权

评论回复
117
wkdxuelei| | 2011-4-30 10:34 | 只看该作者
做个记号,以后再看

使用特权

评论回复
118
wkdxuelei| | 2011-4-30 10:38 | 只看该作者
做个记号,以后再看看

使用特权

评论回复
119
samuel_rain| | 2011-5-4 20:40 | 只看该作者
很有意思...还在学习c中

使用特权

评论回复
120
cecwxf| | 2011-5-7 10:23 | 只看该作者
mark

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则