操作系统课程设计利用多线程和信号量解决哲学家进餐问题 java实现
操作系统课程设计利用多线程和信号量解决哲学家进餐问题java实现
操作系统课程设计利用多线程和信号量解决哲学家进餐问题j a v a实现IMB standardization office【IMB 5AB- IMBK 08- IMB 2C】操作系统课程设计课程设计报告课题：利用信号量和多线程机制实现“哲学家进餐”问题所在学院：信息工程学院班级：计科1201学号：4姓名：魏祥指导教师：徐向英2015年1月 1日目录一、课程设计目标 (3)二、课题内容 (3)三、设计思路 (3)四、源代码 (5)五、运行与测试 (9)六、心得体会 (10)一、课程设计目标学习多线程编程，使用线程的同步机制实现“哲学家进餐”问题。
具体要求：1.创建POSIX线程，实现多线程的并发执行，验证多线程共享进程资源的特性。
2.使用互斥量和条件变量，或使用信号量实现线程的同步互斥。
3.验证“哲学家进餐”问题中的死锁情况，并加以解决。
二、课题内容哲学家进餐问题由Dijkstra提出，问题描述有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，他们的生活方式是交替地进行思考和进餐。
平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。
进餐完毕，放下筷子继续思考。
本次课题要求使用多线程和信号量解决哲学家进餐问题。
并演示产生死锁的情况。
三、设计思路经分析可知，放在桌子上的筷子是临界资源，在一段时间内只允许以为哲学家使用。
为了实现对筷子的互斥，可以用一个信号量表示一只筷子，由着五个信号量构成信号量数组。
当哲学家饥饿时总是先去拿左筷子，成功后在拿右筷子。
当五位哲学家同时拿起左筷子，这是每位哲学家都没有右筷子可以拿，就会造成死锁。
思路1：利用记录型信号量设置值为4的记录型信号量，至多只允许四位哲学家同时去拿左筷子().acquire())，只有拿到左筷子，才能继续拿右筷子().acquire())。
拿到两双筷子之后便可以用餐，用餐完毕，先放下左筷子().release())，再放下右筷子().release())。
哲学家就餐问题代码
哲学家就餐问题代码哲学家就餐问题是一个经典的并发编程问题，描述了五位哲学家围坐在圆桌旁，每个哲学家面前有一碗米饭和一只筷子。
哲学家的生活由思考和就餐两个活动组成，思考时不需要筷子，但就餐时需要同时拿起自己左右两边的筷子才能进餐。
问题在于如何设计算法，使得每位哲学家都能够顺利地进行思考和就餐，而不会发生死锁。
以下是一个简单的解决方案，使用Java语言实现：java.import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;class Philosopher implements Runnable {。
private int id;private Lock leftChopstick;private Lock rightChopstick;public Philosopher(int id, Lock leftChopstick, Lock rightChopstick) {。
this.id = id;this.leftChopstick = leftChopstick;this.rightChopstick = rightChopstick;}。
private void think() {。
System.out.println("哲学家 " + id + " 正在思考");try {。
Thread.sleep((long) (Math.random() 1000));} catch (InterruptedException e) {。
e.printStackTrace();}。
}。
private void eat() {。
leftChopstick.lock();rightChopstick.lock();System.out.println("哲学家 " + id + " 正在就餐");try {。
操作系统课程设计——哲学家进餐问题
操作系统课程设计——哲学家进餐问题1000字哲学家进餐问题是一个经典的多线程同步问题，在操作系统中有着广泛的应用。
因此，在操作系统课程设计中，探究哲学家进餐问题是一件非常有意义的事情。
哲学家进餐问题的场景是：五个哲学家围坐在一张圆桌前，每个哲学家的左右两侧有一只筷子，他们需要利用这两只筷子才能进餐。
每个哲学家有两种状态：思考和进餐。
当一个哲学家处于进餐状态时，他需要同时获取他左右两侧的筷子，进餐结束后，他会释放这两只筷子，进入思考状态。
在这个场景中，如果所有的哲学家都同时想要进餐，那么就可能会出现死锁情况，即所有的哲学家都拿到了左手边的筷子，但都无法拿到右手边的筷子，导致无法进餐。
因此，需要在代码中实现同步互斥机制，避免死锁的发生。
本课程设计中，我使用了Java语言来实现哲学家进餐问题。
在代码实现中，首先定义了哲学家、筷子、餐桌等对象，然后使用线程来模拟哲学家的思考和进餐过程。
为了避免死锁，我使用了Chandy/Misra算法，即每个哲学家先尝试去取左手边的筷子，如果取不到就不再继续等待，而是重新回到思考状态，等待下一个机会。
同时，当一个哲学家取到了左手边的筷子之后，如果发现右手边的筷子已被占用，他就会释放左手边的筷子，重新回到思考状态，等待下一个机会。
在实现过程中，我还使用了信号量机制，保证了线程间的同步互斥。
每个筷子都是一个二元信号量，初始为1，表示可用。
当一个哲学家拿起筷子时，他会将对应的信号量减1，表示不可用。
当哲学家用完筷子之后，会将对应的信号量加1，表示可用。
通过这种方式，实现了对筷子的访问同步。
最后，我对代码进行了测试，模拟了多位哲学家同时进行进餐的过程。
在测试中，我发现哲学家进餐的速度受到筷子的数量和哲学家思考进餐比例的影响。
当筷子数量少于哲学家数量时，容易出现死锁；当哲学家思考和进餐的时间相当时，程序的运行情况比较稳定。
总的来说，本课程设计实现了哲学家进餐问题，通过学习该问题，我更深入地理解了同步互斥机制的重要性，并学会了如何使用信号量来实现同步互斥。
基于Java多线程机制解决哲学家进餐问题的深入探究
基于Java多线程机制解决哲学家进餐问题的深入探究
李金忠;孙永萍;夏洁武
【期刊名称】《井冈山大学学报（自然科学版）》
【年(卷),期】2007(028)006
【摘要】简要阐述了操作系统中哲学家进餐这个经典同步问题,探讨了该问题的多种解决策略,并通过Java语言的多线程编程技术,给出了实现此问题相应解决策略的代码,有效地避免了饥饿和死锁现象的产生.
【总页数】4页(P49-52)
【作者】李金忠;孙永萍;夏洁武
【作者单位】井冈山学院信,息科学与传媒学院,江西,吉安,343009;吉安市招标投标中心,江西,吉安,343000;井冈山学院信,息科学与传媒学院,江西,吉安,343009【正文语种】中文
【中图分类】TP314
【相关文献】
1.基于Java多线程机制解决哲学家进餐问题的深入探究 [J], 李金忠;夏洁武;
2.多线程机制解决哲学家进餐问题的解决策略 [J], 李金忠
3.解决哲学家进餐问题陷入死锁状态的系统改造方案分析 [J], 孙时光;张晋
4.通过回退机制解决哲学家进餐问题 [J], 白戈力;付学良
5.基于Java多线程机制解决哲学家进餐问题的深入探究 [J], 李金忠;夏洁武
因版权原因，仅展示原文概要，查看原文内容请购买。
操作系统课程设计利用多线程和信号量解决哲学家进餐问题java实现
操作系统课程设计课程设计报告课题：利用信号量和多线程机制实现“哲学家进餐”问题所在学院：信息工程学院班级：计科1201学号：121404114姓名：魏祥指导教师：徐向英2015年1月1日目录一、课程设计目标 (3)二、课题内容 (3)三、设计思路 (3)四、源代码 (5)五、运行与测试 (9)六、心得体会 (10)一、课程设计目标学习多线程编程，使用线程的同步机制实现“哲学家进餐”问题。
具体要求：1.创建POSIX线程，实现多线程的并发执行，验证多线程共享进程资源的特性。
2.使用互斥量和条件变量，或使用信号量实现线程的同步互斥。
3. 验证“ 哲学家进餐”问题中的死锁情况，并加以解决。
二、课题内容哲学家进餐问题由Dijkstra提出，问题描述有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，他们的生活方式是交替地进行思考和进餐。
平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。
进餐完毕，放下筷子继续思考。
本次课题要求使用多线程和信号量解决哲学家进餐问题。
并演示产生死锁的情况。
三、设计思路经分析可知，放在桌子上的筷子是临界资源，在一段时间内只允许以为哲学家使用。
为了实现对筷子的互斥，可以用一个信号量表示一只筷子，由着五个信号量构成信号量数组。
当哲学家饥饿时总是先去拿左筷子，成功后在拿右筷子。
当五位哲学家同时拿起左筷子，这是每位哲学家都没有右筷子可以拿，就会造成死锁。
思路1：利用记录型信号量设置值为4的记录型信号量，至多只允许四位哲学家同时去拿左筷子(leftStick.getSema().acquire())，只有拿到左筷子，才能继续拿右筷子(rightStick.getSema().acquire())。
拿到两双筷子之后便可以用餐，用餐完毕，先放下左筷子(leftStick.getSema().release())，再放下右筷子(rightStick.getSema().release())。
操作系统课程设计——哲学家进餐问题
操作系统课程设计课程设计题目:哲学家进餐问题姓名：专业：班级：学号：指导教师：2014年6月10日目录1．设计题目与要求 (2)1.1实验目的 (2)1.2初始条件..............................................................................................错误!未定义书签。
2 总体设计思想及相关知识 (3)2.1总体设计思想 (3)2.2 临界区互斥编程原理 (4)2.3开发环境与工具 (3)3模块说明 (3)3.1 状态改变模块 (4)4. 部分源程序代码及测试结果 (6)5. 课设总结 (9)参考文献 (9)1．设计题目与要求1.1实验目的通过实现哲学家进餐问题的同步,深入了解和掌握进程同步和互斥的原理。
用C++进行线程的创建与撤销代码相对来说比较简单，因为封装比较多，我们能做的就是创建与调用。
当然，代码中也有一些复杂的地方，不是对线程的操作，而是关于界面的显示与操作，单个线程容易创建与撤销，但难的是合理的“监控”与组织多个线程并及时进行状态的显示。
虽然用程序语言实现了进程创建（当然，这是在并不会理论的情况下），但还是没弄清理论的实质。
可能理论更抽象些吧。
在平常的编程中，虽然经常遇到过要使用多线程的问题，但没有去试过从操作系统的角度去考虑线程的运行，在以后的学习中，我想还是会深入了解与学习这方面的东西的。
1.2设计要求哲学家有N个，也定全体到达后开始讨论：在讨论的间隙哲学家进餐，每人进餐时都需使用刀、叉各一把，所有哲学家刀和叉都拿到后才能进餐。
哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。
（1）操作系统：windows（2）程序设计语言：C++（3）设定圆桌上有六个哲学家，三对刀叉，如下图摆放：图1-1 哲学家进餐问题设定图2 总体设计思想及相关知识2.1总体设计思想哲学家的生活就是思考和吃饭，即思考，就餐，再思考，往复循环。
操作系统课程设计——哲学家进餐问题
操作系统课程设计——哲学家进餐问题操作系统课程设计课程设计题目:哲学家进餐问题姓名：专业：班级：学号：指导教师：2014年6月10日目录1．设计题目与要求 (2)1.1实验目的 (2)1.2初始条件 ....... 错误!未定义书签。
2 总体设计思想及相关知识错误!未定义书签。
2.1总体设计思想 ... 错误!未定义书签。
2.2 临界区互斥编程原理 02.3开发环境与工具 (3)3模块说明 (3)3.1 状态改变模块 (4)4. 部分源程序代码及测试结果 (6)5. 课设总结 (5)参考文献 (6)1．设计题目与要求1.1实验目的通过实现哲学家进餐问题的同步,深入了解和掌握进程同步和互斥的原理。
用C++进行线程的创建与撤销代码相对来说比较简单，因为封装比较多，我们能做的就是创建与调用。
当然，代码中也有一些复杂的地方，不是对线程的操作，而是关于界面的显示与操作，单个线程容易创建与撤销，但难的是合理的“监控”与组织多个线程并及时进行状态的显示。
虽然用程序语言实现了进程创建（当然，这是在并不会理论的情况下），但还是没弄清理论的实质。
可能理论更抽象些吧。
在平常的编程中，虽然经常遇到过要使用多线程的问题，但没有去试过从操作系统的角度去考虑线程的运行，在以后的学习中，我想还是会深入了解与学习这方面的东西的。
1.2设计要求哲学家有N个，也定全体到达后开始讨论：在讨论的间隙哲学家进餐，每人进餐时都需使用刀、叉各一把，所有哲学家刀和叉都拿到后才能进餐。
哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。
（1）操作系统：windows（2）程序设计语言：C++（3）设定圆桌上有六个哲学家，三对刀叉，如下图摆放：“等待”->“进餐”：只有一个哲学家处于等待进餐状态，且左右手两边的餐具都处于“空闲”状态时，可以发生这种状态改变。
此状态改变发生后，哲学家拿起左右手两边的餐具。
“进餐”->“思考”：此状态改变发生后，哲学家放下左右手上的餐具。
哲学家就餐的问题--java实现
哲学家就餐的问题--java实现先来看看运⾏结果吧：代码分为4个⽂件：Chopstick.javapackage Philosopher;/*** 表⽰筷⼦的类* */public class Chopstick{public Chopstick(){}public Chopstick(int id){this.id = id;}public boolean isAvailable(){return available;}public void setAvailable(boolean available){this.available = available;}public int getId(){return id;}public void setId(int id){this.id = id;}@Overridepublic String toString(){return "筷⼦" + id;}/*** 表⽰筷⼦是否可⽤* */private volatile boolean available = true;private int id;} ChopstickArray.javapackage Philosopher;public class ChopstickArray{public ChopstickArray(){}public ChopstickArray(int size){chopsticks = new Chopstick[size];for(int i = 0; i < chopsticks.length; ++i){chopsticks[i] = new Chopstick(i);}}public Chopstick getId(int id){return chopsticks[id];}public Chopstick getLast(int id){if(id == 0){return chopsticks[chopsticks.length - 1];}else{return chopsticks[id - 1];}}private Chopstick[] chopsticks;}DiningPhilosophersFrame.javapackage Philosopher;import java.awt.FlowLayout;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JScrollPane;import javax.swing.JTextArea;public class DiningPhilosophersFrame extends JFrame{public DiningPhilosophersFrame(){panel2.setLayout(new GridLayout(2, 2, 3, 3));panel2.add(label2);panel2.add(label3);panel2.add(label4);JScrollPane js1 = new JScrollPane(thinkingTextArea,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);JScrollPane js2 = new JScrollPane(eatingTextArea,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);JScrollPane js3 = new JScrollPane(waitingTextArea,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);panel2.add(js1);panel2.add(js2);panel2.add(js3);panel1.setLayout(new FlowLayout());panel1.add(label1);panel1.add(panel2);panel1.add(button);setContentPane(panel1);button.addActionListener(new ActionListener(){@Overridepublic void actionPerformed(ActionEvent e){ChopstickArray chopstickArray = new ChopstickArray(5); for(int i = 0; i < 5; i++){new Thread(new Philosopher(i, chopstickArray,thinkingTextArea, eatingTextArea, waitingTextArea)) .start();}}});setSize(300, 400);setVisible(true);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }public static void main(String[] args){new DiningPhilosophersFrame();}private final JPanel panel1 = new JPanel();private final JPanel panel2 = new JPanel();private final JTextArea thinkingTextArea = new JTextArea(5, 10);private final JTextArea eatingTextArea = new JTextArea(5, 10);private final JTextArea waitingTextArea = new JTextArea(5, 10);JLabel label1 = new JLabel("哲学家问题");JLabel label2 = new JLabel("思考");JLabel label3 = new JLabel("吃饭");JLabel label4 = new JLabel("等待");JButton button = new JButton("开始运⾏");} Philosopher.javapackage Philosopher;import java.util.Random;import javax.swing.JTextArea;public class Philosopher implements Runnable{public Philosopher(){}public Philosopher(int id, ChopstickArray chopstickArray,JTextArea thinkingTextArea, JTextArea eatingtextArea,JTextArea waitingTextArea){this.id = id;this.chopstickArray = chopstickArray;this.thinkingTextArea = thinkingTextArea;this.eatingTextArea = eatingtextArea;this.waitingTextArea = waitingTextArea;}public synchronized void thinking(){if(state){ // 如果在思考,说明这个哲学家两⾯的筷⼦没⽤chopstickArray.getId(id).setAvailable(true);chopstickArray.getLast(id).setAvailable(true);String text = thinkingTextArea.getText();thinkingTextArea.setText(text + this + "在思考\n");try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}state = false;}public synchronized void eating(){if(!state){ // 在思考if(chopstickArray.getId(id).isAvailable()){ // 如果哲学家右⼿边的筷⼦可⽤ if(chopstickArray.getLast(id).isAvailable()){ // 如果左⼿边的筷⼦也可⽤ // 然后将这个能吃饭的哲学家两侧的筷⼦都设置为不可⽤chopstickArray.getId(id).setAvailable(false);chopstickArray.getLast(id).setAvailable(false);String text = eatingTextArea.getText();eatingTextArea.setText(text + this + "在吃饭\n");try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}}else{// 右⼿边的筷⼦可⽤，但是左⼿边的不可⽤String str = waitingTextArea.getText();waitingTextArea.setText(str + this + "在等待"+ chopstickArray.getLast(id) + "\n");try{wait(new Random().nextInt(100));}catch(Exception e){e.printStackTrace();}}}else{// 如果哲学家右⼿边的筷⼦不可⽤则等待String str = waitingTextArea.getText();waitingTextArea.setText(str + this + "在等待"+ chopstickArray.getId(id) + "\n");try{wait(new Random().nextInt(100)); }catch(Exception e){e.printStackTrace();}}}state = true;}@Overridepublic void run(){for(int i = 0; i < 10; ++i){thinking();eating();}}@Overridepublic String toString(){return " 哲学家 " + id;}private int id;private boolean state;ChopstickArray chopstickArray;JTextArea thinkingTextArea;JTextArea eatingTextArea;JTextArea waitingTextArea;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计课程设计报告课题：利用信号量和多线程机制实现“哲学家进餐”问题所在学院：信息工程学院班级：计科1201学号：**********名：**指导教师：***2015年1月1日目录一、课程设计目标 (3)二、课题内容 (3)三、设计思路 (3)四、源代码 (5)五、运行与测试 (9)六、心得体会 (10)一、课程设计目标学习多线程编程，使用线程的同步机制实现“哲学家进餐”问题。
具体要求：1.创建POSIX线程，实现多线程的并发执行，验证多线程共享进程资源的特性。
2.使用互斥量和条件变量，或使用信号量实现线程的同步互斥。
3. 验证“ 哲学家进餐”问题中的死锁情况，并加以解决。
二、课题内容哲学家进餐问题由Dijkstra提出，问题描述有五个哲学家共用一张圆桌，分别坐在周围的五张椅子上，在圆桌上有五个碗和五支筷子，他们的生活方式是交替地进行思考和进餐。
平时，一个哲学家进行思考，饥饿时便试图取用其左右最靠近他的筷子，只有在他拿到两只筷子时才能进餐。
进餐完毕，放下筷子继续思考。
本次课题要求使用多线程和信号量解决哲学家进餐问题。
并演示产生死锁的情况。
三、设计思路经分析可知，放在桌子上的筷子是临界资源，在一段时间内只允许以为哲学家使用。
为了实现对筷子的互斥，可以用一个信号量表示一只筷子，由着五个信号量构成信号量数组。
当哲学家饥饿时总是先去拿左筷子，成功后在拿右筷子。
当五位哲学家同时拿起左筷子，这是每位哲学家都没有右筷子可以拿，就会造成死锁。
思路1：利用记录型信号量设置值为4的记录型信号量，至多只允许四位哲学家同时去拿左筷子(leftStick.getSema().acquire())，只有拿到左筷子，才能继续拿右筷子(rightStick.getSema().acquire())。
拿到两双筷子之后便可以用餐，用餐完毕，先放下左筷子(leftStick.getSema().release())，再放下右筷子(rightStick.getSema().release())。
这样便可以避免思索问题。
思路2：利用AND型信号量要求每个哲学家必须获取两个筷子的时候才能够进餐，只得到一只筷子不能进餐时，要求释放那一只筷子。
可以使用AND型信号量将左筷子和右筷子信号量的获取组成一个原子操作。
如此也可以避免死锁问题。
本次课程设计是在windows系统下完成，编程语言为java，开发环境:Eclipse。
由于在java语言中使用记录型信号量更为方便，所以本次课题我使用的是思路一。
这两行注释掉，取消至多只允许四位哲学家一起拿起左筷子的限制，就会产生死锁。
四、源代码//在Windows下运行,筷子类(ChopStick.java)import java.util.concurrent.Semaphore;public class ChopStick {private int ID;private boolean available;private Semaphore semaphore = new Semaphore(1);public ChopStick(int ID){this.ID = ID;this.available = true;this.semaphore = new Semaphore(1);}public void setAvai(boolean available){this.available = available;}public boolean getAvai(){return this.available;}public Semaphore getSema(){return this.semaphore;}public void setSema(Semaphore sema){this.semaphore = sema;}public int getId(){return this.ID;}}哲学家类(Philosopher.java)import java.util.concurrent.Semaphore;public class Philosopher implements Runnable{private int ID;static Semaphore room = new Semaphore(4);private ChopStick leftStick;private ChopStick rightStick;public Philosopher(int ID, ChopStick cs1, ChopStick cs2){this.ID = ID;this.leftStick = cs1;this.rightStick = cs2;}public void getLeftChopStick(){this.leftStick.setAvai(false);}public int getId(){return ID;}public void eat(){leftStick.setAvai(false);rightStick.setAvai(false);System.out.println("哲学家"+ this.getId() + "正在用餐。
");}public void think(){System.out.println("哲学家" + this.getId() + "正在思考。
");}public void finishEat(){System.out.println("哲学家" + this.getId() + "用餐结束,正在思考。
");leftStick.setAvai(true);rightStick.setAvai(true);}public void readyToEat(){System.out.println("哲学家" + this.getId() + "饿了准备用餐。
");}public void cannotEat(){System.out.println("哲学家" + this.getId() + "缺少筷子，不能用餐，等待。
");}public void run(){try{room.acquire();this.readyToEat();if(this.leftStick.getSema().availablePermits() == 0 ||this.leftStick.getSema().availablePermits() == 0){this.cannotEat();}this.leftStick.getSema().acquire();Thread.sleep(1000 * 1);this.rightStick.getSema().acquire();this.eat();Thread.sleep(1000 * 2);this.finishEat();this.leftStick.getSema().release();this.rightStick.getSema().release();room.release();}catch(InterruptedException ex){ex.toString();}}}测试(Test.java)import java.util.concurrent.*;import java.util.Scanner;public class Test {public static void main(String[] args){Scanner input = new Scanner(System.in);menu();int choice = input.nextInt();while(choice != 1){if(choice == 0){ChopStick[] chopStick = new ChopStick[5];for(int i = 0; i < 5; i ++){chopStick[i] = new ChopStick(i);}ExecutorService excutor = Executors.newFixedThreadPool(5);Philosopher ph0 = new Philosopher(0, chopStick[0], chopStick[1]);excutor.execute(new Philosopher(0, chopStick[0], chopStick[1]));excutor.execute(new Philosopher(1, chopStick[1], chopStick[2]));excutor.execute(new Philosopher(2, chopStick[2], chopStick[3]));excutor.execute(new Philosopher(3, chopStick[3], chopStick[4]));excutor.execute(new Philosopher(4, chopStick[4], chopStick[0]));excutor.shutdown();}choice = input.nextInt();menu();}}public static void menu(){System.out.println("0: 演示");System.out.println("1: 结束");}}五、运行与测试1.运行界面2.死锁演示3.无死锁演示六、心得体会本次课程设计我总得来说花的时间不是太多，代码加起来一共不超过两百行。
我只用了一种思路来完成。
思路一完成之后，我也尝试着用思路二完成，但是AND型信号量的问题很难解决，最后便放弃了。
拿到课题之前我对哲学家进餐问题了解的还不是很透彻，我利用网络和查询课本彻底搞懂了哲学家进餐问题。
并且得到两种解决思路。
通过此次的课程设计，我想我对多线程的编程理解更深了一点，虽然说死锁的出现几率不是非常的大，但是还是有可能会出现，一旦出现，程序就会锁在哪里，不能继续执行。
所以解决死锁是非常必要的。
由于我在学习java语言的时候，里面有专门降到多线程编程，这对我顺利的完成此次的课程设计有很大的帮助。
Jdk里面丰富的类库也省去了我编写线程类和信号量类的功夫。
虽然说不必考虑这些，但编写代码的时候我还是遇到了一些问题，多线程的执行和信号量的设置让我话费了一些时间。