设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › 地图设计
123456789
返回列表 发新帖

地图设计

[复制链接]
FishC
发表于 2024-4-15 19:02:15 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:01
@FishC1本例要求用Java编写一个程序.
一圆桌前坐着5 ...


以下是使用Java编写的解决小朋友就餐问题的代码示例：

  1. public class DiningProblem {
  2.     private static boolean[] forks = {true, true, true, true, true}; // 代表5根筷子的使用情况

  4.     public static void main(String[] args) {
  5.         LittleFriend[] friends = new LittleFriend[5];
  6.         for (int i = 0; i < 5; i++) {
  7.             friends[i] = new LittleFriend(i); // 创建5个小朋友
  8.             friends[i].start(); // 启动小朋友的线程
  9.         }
  10.     }

  12.     static class LittleFriend extends Thread {
  13.         private int id;

  15.         public LittleFriend(int id) {
  16.             this.id = id;
  17.         }

  19.         @Override
  20.         public void run() {
  21.             while (true) {
  22.                 playing(); // 小朋友玩耍
  23.                 try {
  24.                     Thread.sleep(1000); // 等待一段时间后再尝试获取筷子
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.                 eating(); // 小朋友吃饭
  29.                 try {
  30.                     Thread.sleep(1000); // 等待一段时间后再继续玩耍
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }

  37.         private void playing() {
  38.             System.out.println("小朋友" + id + "正在玩耍");
  39.         }

  41.         private void eating() {
  42.             synchronized(forks) {
  43.                 int leftForkIndex = id; // 左手边筷子的索引
  44.                 int rightForkIndex = (id + 1) % 5; // 右手边筷子的索引

  46.                 while (!forks[leftForkIndex] || !forks[rightForkIndex]) { // 如果左右手的筷子有一只被占用，则等待
  47.                     try {
  48.                         forks.wait();
  49.                     } catch (InterruptedException e) {
  50.                         e.printStackTrace();
  51.                     }
  52.                 }

  54.                 forks[leftForkIndex] = false; // 获取左手边的筷子
  55.                 forks[rightForkIndex] = false; // 获取右手边的筷子

  57.                 System.out.println("小朋友" + id + "拿起了左手边的筷子和右手边的筷子，开始吃饭");

  59.                 try {
  60.                     Thread.sleep(2000); // 模拟吃饭的时间
  61.                 } catch (InterruptedException e) {
  62.                     e.printStackTrace();
  63.                 }

  65.                 forks[leftForkIndex] = true; // 释放左手边的筷子
  66.                 forks[rightForkIndex] = true; // 释放右手边的筷子
  67.                 forks.notifyAll(); // 唤醒其他等待获取筷子的线程

  69.                 System.out.println("小朋友" + id + "放下了筷子，吃饭结束");
  70.             }
  71.         }
  72.     }
  73. }
复制代码


在测试类中调用5次以上方法，代表5位小朋友，并写出小朋友在干什么

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:11:19 | 显示全部楼层
@FishC1 根据此代码对你代码进行修改
  1.   //每个小朋友相当于一个线程
  2. public class Child extends Thread{
  3.     private String name;
  4.     private Chopsticks chopsticks;
  5.     public Child(String name,Chopsticks chopsticks){
  6.         super(name);
  7.         this.name=name;
  8.         this.chopsticks=chopsticks;
  9.     }
  10.     public void run(){
  11.         while(true){
  12.             playing();
  13.             chopsticks.takeChopsticks();
  14.             eating();
  15.             chopsticks.putChopsticks();
  16.         }
  17.     }
  18.     public void eating(){
  19.         System.out.println("小朋友"+name+"在吃饭");
  20.         try {
  21.             sleep(1000);//模拟吃饭，占用一段时间
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26.     public void playing(){
  27.         System.out.println("小朋友"+name+"在玩游戏");
  28.         try {
  29.             sleep(1000);//模拟玩耍，占用一段时间
  30.         } catch (InterruptedException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }
  35. class Chopsticks{
  36.     //5只筷子，初始为都未被用
  37.     private boolean[] used={false,false,false,false,false};
  38.     //只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  39.     public synchronized void takeChopsticks(){
  40. //请完善程序，获得当前小朋友线程的名字
  41.     String name =Thread.currentThread().getName();
  42.     //请完善程序，获得当前小朋友线程的名字所对应的整数值
  43.     int i =Integer.parseInt(name);
  44. //请完善程序中的条件，判定当前小朋友左右的筷子是否都未被占用，否则等待
  45.         while(used[i]||used[(i+1)%5]){
  46.         try {
  47.             wait();//如果左右手有一只正被使用，等待
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }

  53.     used[i ]= true;
  54.     used[(i+1)%5]=true;
  55. }
  56.     /*必须同时释放左右手的筷子*/
  57.     public synchronized void putChopsticks(){
  58.         String name = Thread.currentThread().getName();
  59.         int i = Integer.parseInt(name);
  60. //请完善程序，将当前小朋友左右的筷子状态更新为未被占用
  61.         used[i]=false;
  62.         used[(i+1)%5]=false;
  63.         
  64. //请完善程序，唤醒所有正在等待的小朋友线程
  65.         notifyAll();
  66.     }
  67. }
  68. class Test {
  69.     public static void main(String []args){
  70.         Chopsticks chopsticks = new Chopsticks();
  71.         new Child("0",chopsticks).start();
  72. //请完善程序，再依次生成四个小朋友线程并启动
  73.         new Child("1",chopsticks).start();
  74.         new Child("2",chopsticks).start();
  75.         new Child("3",chopsticks).start();
  76.         new Child("4",chopsticks).start();

  78.     }
  79. }


复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:13:03 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:11
@FishC1 根据此代码对你代码进行修改  //每个小朋友相 ...


你的代码已经非常接近题目要求的解决方案了，但还需要稍作修改。下面是修改后的代码：

  1. public class Child extends Thread {
  2.     private String name;
  3.     private Chopsticks chopsticks;

  5.     public Child(String name, Chopsticks chopsticks) {
  6.         super(name);
  7.         this.name = name;
  8.         this.chopsticks = chopsticks;
  9.     }

  11.     public void run() {
  12.         while (true) {
  13.             playing();
  14.             chopsticks.takeChopsticks(Integer.parseInt(name));
  15.             eating();
  16.             chopsticks.putChopsticks(Integer.parseInt(name));
  17.         }
  18.     }

  20.     public void eating() {
  21.         System.out.println("小朋友" + name + "在吃饭");
  22.         try {
  23.             sleep(1000);// 模拟吃饭，占用一段时间
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }

  29.     public void playing() {
  30.         System.out.println("小朋友" + name + "在玩游戏");
  31.         try {
  32.             sleep(1000);// 模拟玩耍，占用一段时间
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

  39. class Chopsticks {
  40.     // 5只筷子，初始为都未被用
  41.     private boolean[] used = { false, false, false, false, false };

  43.     // 只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  44.     public synchronized void takeChopsticks(int i) {
  45.         // 如果左右手有一只被使用，等待
  46.         while (used[i] || used[(i + 1) % 5]) {
  47.             try {
  48.                 wait();
  49.             } catch (InterruptedException e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }
  53.         // 将当前小朋友左右的筷子状态更新为被占用
  54.         used[i] = true;
  55.         used[(i + 1) % 5] = true;
  56.     }

  58.     /* 必须同时释放左右手的筷子 */
  59.     public synchronized void putChopsticks(int i) {
  60.         // 将当前小朋友左右的筷子状态更新为未被占用
  61.         used[i] = false;
  62.         used[(i + 1) % 5] = false;
  63.         // 唤醒所有正在等待的小朋友线程
  64.         notifyAll();
  65.     }
  66. }

  68. class Test {
  69.     public static void main(String[] args) {
  70.         Chopsticks chopsticks = new Chopsticks();
  71.         // 依次创建并启动四个小朋友线程
  72.         for (int i = 0; i < 5; i++) {
  73.             new Child(Integer.toString(i), chopsticks).start();
  74.         }
  75.     }
  76. }
复制代码


请注意，以上代码使用了`wait()`和`notifyAll()`方法来进行线程间的同步与通信，这样就能够保证每个小朋友都能成功就餐。另外，为了避免数组越界错误，需要在`takeChopsticks()`方法和`putChopsticks()`方法中相应地修改索引计算方式。

在测试类中，我们通过循环依次创建并启动了五个小朋友线程。每个小朋友在执行过程中会先玩耍，然后尝试获取筷子再开始就餐，最后释放筷子继续玩耍。整个过程会一直循环执行下去。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:13:10 | 显示全部楼层
@FishC1根据此代码对你代码进行修改
  1.   //每个小朋友相当于一个线程
  2. public class Child extends Thread{
  3.     private String name;
  4.     private Chopsticks chopsticks;
  5.     public Child(String name,Chopsticks chopsticks){
  6.         super(name);
  7.         this.name=name;
  8.         this.chopsticks=chopsticks;
  9.     }
  10.     public void run(){
  11.         while(true){
  12.             playing();
  13.             chopsticks.takeChopsticks();
  14.             eating();
  15.             chopsticks.putChopsticks();
  16.         }
  17.     }
  18.     public void eating(){
  19.         System.out.println("小朋友"+name+"在吃饭");
  20.         try {
  21.             sleep(1000);//模拟吃饭，占用一段时间
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26.     public void playing(){
  27.         System.out.println("小朋友"+name+"在玩游戏");
  28.         try {
  29.             sleep(1000);//模拟玩耍，占用一段时间
  30.         } catch (InterruptedException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }
  35. class Chopsticks{
  36.     //5只筷子，初始为都未被用
  37.     private boolean[] used={false,false,false,false,false};
  38.     //只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  39.     public synchronized void takeChopsticks(){
  40. //请完善程序，获得当前小朋友线程的名字
  41.     String name =Thread.currentThread().getName();
  42.     //请完善程序，获得当前小朋友线程的名字所对应的整数值
  43.     int i =Integer.parseInt(name);
  44. //请完善程序中的条件，判定当前小朋友左右的筷子是否都未被占用，否则等待
  45.         while(used[i]||used[(i+1)%5]){
  46.         try {
  47.             wait();//如果左右手有一只正被使用，等待
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }

  53.     used[i ]= true;
  54.     used[(i+1)%5]=true;
  55. }
  56.     /*必须同时释放左右手的筷子*/
  57.     public synchronized void putChopsticks(){
  58.         String name = Thread.currentThread().getName();
  59.         int i = Integer.parseInt(name);
  60. //请完善程序，将当前小朋友左右的筷子状态更新为未被占用
  61.         used[i]=false;
  62.         used[(i+1)%5]=false;
  63.         
  64. //请完善程序，唤醒所有正在等待的小朋友线程
  65.         notifyAll();
  66.     }
  67. }
  68. class Test {
  69.     public static void main(String []args){
  70.         Chopsticks chopsticks = new Chopsticks();
  71.         new Child("0",chopsticks).start();
  72. //请完善程序，再依次生成四个小朋友线程并启动
  73.         new Child("1",chopsticks).start();
  74.         new Child("2",chopsticks).start();
  75.         new Child("3",chopsticks).start();
  76.         new Child("4",chopsticks).start();

  78.     }
  79. }


复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:13:39 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:13
@FishC1根据此代码对你代码进行修改  //每个小朋友相 ...


你的代码已经基本符合题目要求了，只需要做一些微调。下面是修改后的代码：

  1. public class Child extends Thread {
  2.     private String name;
  3.     private Chopsticks chopsticks;

  5.     public Child(String name, Chopsticks chopsticks) {
  6.         super(name);
  7.         this.name = name;
  8.         this.chopsticks = chopsticks;
  9.     }

  11.     public void run() {
  12.         while (true) {
  13.             playing();
  14.             chopsticks.takeChopsticks(name);
  15.             eating();
  16.             chopsticks.putChopsticks(name);
  17.         }
  18.     }

  20.     public void eating() {
  21.         System.out.println("小朋友" + name + "在吃饭");
  22.         try {
  23.             sleep(1000);// 模拟吃饭，占用一段时间
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }

  29.     public void playing() {
  30.         System.out.println("小朋友" + name + "在玩游戏");
  31.         try {
  32.             sleep(1000);// 模拟玩耍，占用一段时间
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

  39. class Chopsticks {
  40.     // 5根筷子，初始状态为都未被使用
  41.     private boolean[] used = {false, false, false, false, false};

  43.     public synchronized void takeChopsticks(String name) {
  44.         int left = Integer.parseInt(name); // 当前小朋友线程的名字所对应的整数值
  45.         int right = (Integer.parseInt(name) + 1) % 5; // 当前小朋友右手边筷子的索引

  47.         while (used[left] || used[right]) { // 判定当前小朋友左右的筷子是否都未被占用，否则等待
  48.             try {
  49.                 wait(); // 如果左右手有一只正被使用，等待
  50.             } catch (InterruptedException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }

  55.         used[left] = true;
  56.         used[right] = true;
  57.     }

  59.     public synchronized void putChopsticks(String name) {
  60.         int left = Integer.parseInt(name); // 当前小朋友线程的名字所对应的整数值
  61.         int right = (Integer.parseInt(name) + 1) % 5; // 当前小朋友右手边筷子的索引

  63.         used[left] = false;
  64.         used[right] = false;

  66.         notifyAll(); // 唤醒所有正在等待的小朋友线程
  67.     }
  68. }

  70. class Test {
  71.     public static void main(String[] args) {
  72.         Chopsticks chopsticks = new Chopsticks();

  74.         // 依次创建并启动五个小朋友线程
  75.         for (int i = 0; i < 5; i++) {
  76.             new Child(Integer.toString(i), chopsticks).start();
  77.         }
  78.     }
  79. }
复制代码


这个代码会创建五个小朋友线程，每个小朋友会循环执行玩耍、拿起筷子、吃饭、放下筷子的过程。通过使用synchronized关键字和wait/notify机制，确保每个小朋友在拿起筷子时只能拿到左右两只筷子，从而避免了饥饿问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:15:28 | 显示全部楼层
@FishC1对代码进行修改，当小朋友全部吃完饭停止循环
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:15:50 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:15
@FishC1对代码进行修改，当小朋友全部吃完饭停止循环


要实现小朋友全部吃完饭后停止循环，可以增加一个计数器来记录还在吃饭的小朋友数量。当计数器为0时，表示所有小朋友都吃完了，可以停止循环。

以下是修改后的代码：

  1. public class Child extends Thread {
  2.     private static int numOfChildren = 5;
  3.     private static int numOfChildrenEating = numOfChildren;
  4.   
  5.     private String name;
  6.     private Chopsticks chopsticks;

  8.     public Child(String name, Chopsticks chopsticks) {
  9.         super(name);
  10.         this.name = name;
  11.         this.chopsticks = chopsticks;
  12.     }

  14.     public void run() {
  15.         while (numOfChildrenEating > 0) {
  16.             playing();
  17.             chopsticks.takeChopsticks();
  18.             eating();
  19.             chopsticks.putChopsticks();
  20.             numOfChildrenEating--;
  21.         }
  22.     }

  24.     public void eating() {
  25.         System.out.println("小朋友" + name + "在吃饭");
  26.         try {
  27.             sleep(1000); // 模拟吃饭，占用一段时间
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }

  33.     public void playing() {
  34.         System.out.println("小朋友" + name + "在玩游戏");
  35.         try {
  36.             sleep(1000); // 模拟玩耍，占用一段时间
  37.         } catch (InterruptedException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

  43. class Chopsticks {
  44.     // 5只筷子，初始为都未被用
  45.     private boolean[] used = { false, false, false, false, false };

  47.     // 只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  48.     public synchronized void takeChopsticks() {
  49.         String name = Thread.currentThread().getName();
  50.         int i = Integer.parseInt(name);

  52.         while (used[i] || used[(i + 1) % used.length]) {
  53.             try {
  54.                 wait(); // 如果左右手有一只正被使用，等待
  55.             } catch (InterruptedException e) {
  56.                 e.printStackTrace();
  57.             }
  58.         }

  60.         used[i] = true;
  61.         used[(i + 1) % used.length] = true;
  62.     }

  64.     /* 必须同时释放左右手的筷子 */
  65.     public synchronized void putChopsticks() {
  66.         String name = Thread.currentThread().getName();
  67.         int i = Integer.parseInt(name);

  69.         used[i] = false;
  70.         used[(i + 1) % used.length] = false;

  72.         notifyAll(); // 唤醒所有正在等待的小朋友线程
  73.     }
  74. }

  76. class Test {
  77.     public static void main(String[] args) {
  78.         Chopsticks chopsticks = new Chopsticks();

  80.         for (int i = 0; i < numOfChildren; i++) {
  81.             new Child(String.valueOf(i), chopsticks).start();
  82.         }
  83.     }
  84. }
复制代码


这样，当所有小朋友都吃完饭后，循环就会停止。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:18:42 | 显示全部楼层

@FishC1对代码进行修改，每个小朋友已经吃饭后就不会再次吃饭，然后五个小朋友都吃过饭后循环结束
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:19:00 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:18
@FishC1对代码进行修改，每个小朋友已经吃饭后就不会 ...


要实现每个小朋友只吃一次饭，并且当五个小朋友都吃过饭后循环结束，可以修改代码如下：

  1. public class Child extends Thread{
  2.     private String name;
  3.     private Chopsticks chopsticks;
  4.     private static int count = 0; // 记录已经吃过饭的小朋友数量

  6.     public Child(String name,Chopsticks chopsticks){
  7.         super(name);
  8.         this.name=name;
  9.         this.chopsticks=chopsticks;
  10.     }

  12.     public void run(){
  13.         while(count < 5){ // 当还有小朋友没有吃饭时循环
  14.             playing();
  15.             chopsticks.takeChopsticks();
  16.             eating();
  17.             chopsticks.putChopsticks();
  18.             count++; // 吃过饭的小朋友数量加一
  19.         }
  20.     }

  22.     public void eating(){
  23.         System.out.println("小朋友"+name+"在吃饭");
  24.         try {
  25.             sleep(1000);//模拟吃饭，占用一段时间
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  29.     }

  31.     public void playing(){
  32.         System.out.println("小朋友"+name+"在玩游戏");
  33.         try {
  34.             sleep(1000);//模拟玩耍，占用一段时间
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

  41. class Chopsticks{
  42.     private boolean used[] = {false,false,false,false,false}; // 五只筷子，初始状态都未被使用

  44.     public synchronized void takeChopsticks(){
  45.         String name = Thread.currentThread().getName();
  46.         int i = Integer.parseInt(name);

  48.         while(used[i] || used[(i+1) % 5]){ // 当左手或右手筷子被占用时等待
  49.             try {
  50.                 wait();
  51.             } catch (InterruptedException e) {
  52.                 e.printStackTrace();
  53.             }
  54.         }

  56.         used[i] = true; // 将左手筷子状态设置为被占用
  57.         used[(i+1) % 5] = true; // 将右手筷子状态设置为被占用
  58.     }

  60.     public synchronized void putChopsticks(){
  61.         String name = Thread.currentThread().getName();
  62.         int i = Integer.parseInt(name);

  64.         used[i] = false; // 将左手筷子状态设置为未被占用
  65.         used[(i+1) % 5] = false; // 将右手筷子状态设置为未被占用

  67.         notifyAll(); // 唤醒所有正在等待的小朋友线程
  68.     }
  69. }

  71. class Test {
  72.     public static void main(String args){
  73.         Chopsticks chopsticks = new Chopsticks();

  75.         for(int i = 0; i < 5; i++){
  76.             new Child(Integer.toString(i),chopsticks).start(); // 生成五个小朋友线程并启动
  77.         }
  78.     }
  79. }
复制代码


这样，每个小朋友只会吃一次饭，当五个小朋友都吃过饭后，循环结束。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:25:18 | 显示全部楼层
@FishC1一圆桌前坐着5位小朋友，两个人中间有一只筷子，桌子中央有面条。小朋友边吃边玩，当饿了的时候拿起左右两只筷子吃饭，必须拿到两只筷子才能吃饭。但是，小朋友在吃饭过程中，可能会发生5个小朋友都拿起自己右手边的筷子，这样每个小朋友都因缺少左手边的筷子而没有办法吃饭。本案例要求编写一个程序解决小朋友就餐问题，使每个小朋友都能成功就餐。(1)        查看运行结果分析后，每个小朋友相当于一个线程，所以先创建一个Littlefriend()方法作为小朋友。
(2)        查看运行结果分析后，创建eating()方法作为小朋友吃饭时的线程，创建playing()方法作为小朋友玩耍时的线程。
(3)        查看运行结果分析后，需要在获取筷子的方法Fork中先定义一个boolean类型的数组，代表5根筷子的使用情况；再使用synchronized线程锁来控制只有左右手的筷子都未被使用时，才允许获取筷子，且必须同时获取左右手筷子。
(4)        查看运行结果分析后，需要在释放左右手筷子的方法putFork中使用synchronized线程锁来释放筷子。
(5)        最后在测试类中调用5次以上方法，代表5位小朋友。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:25:49 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:25
@FishC1一圆桌前坐着5位小朋友，两个人中间有一只筷子 ...


下面是一个解决小朋友就餐问题的示例代码：

  1. public class DiningProblem {
  2.     // 筷子的使用情况，true代表筷子可用，false代表筷子被占用
  3.     private boolean[] forks = new boolean[5];

  5.     public synchronized void getForks(int i) {
  6.         int left = i;
  7.         int right = (i + 1) % 5;

  9.         // 只有左右手的筷子都未被使用时才允许获取筷子
  10.         while (!forks[left] || !forks[right]) {
  11.             try {
  12.                 wait();
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.         }

  18.         forks[left] = false;  // 获取左手边筷子
  19.         forks[right] = false;  // 获取右手边筷子
  20.         System.out.println("小朋友" + i + "拿到了左右手的筷子，可以开始吃饭啦！");
  21.     }

  23.     public synchronized void putForks(int i) {
  24.         int left = i;
  25.         int right = (i + 1) % 5;

  27.         forks[left] = true;  // 释放左手边筷子
  28.         forks[right] = true;  // 释放右手边筷子
  29.         System.out.println("小朋友" + i + "吃完饭啦，放下了左右手的筷子！");

  31.         notifyAll();  // 唤醒其他正在等待的小朋友
  32.     }

  34.     public static void main(String[] args) {
  35.         DiningProblem dining = new DiningProblem();

  37.         for (int i = 0; i < 5; i++) {
  38.             final int index = i;
  39.             Thread eatingThread = new Thread(() -> {
  40.                 dining.getForks(index);
  41.                 try {
  42.                     Thread.sleep(2000);  // 模拟吃饭时间
  43.                 } catch (InterruptedException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.                 dining.putForks(index);
  47.             });

  49.             Thread playingThread = new Thread(() -> {
  50.                 try {
  51.                     Thread.sleep(1000);  // 模拟玩耍时间
  52.                 } catch (InterruptedException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             });

  57.             eatingThread.start();
  58.             playingThread.start();
  59.         }
  60.     }
  61. }
复制代码


在这个示例代码中，通过使用线程锁和条件变量来实现小朋友拿筷子和放筷子的同步。每个小朋友都有一个对应的eatingThread和playingThread，其中eatingThread用于模拟拿起筷子吃饭的过程，playingThread用于模拟玩耍的过程。每个小朋友先尝试获取左右手边的筷子，如果有一只或两只筷子被占用，则进入等待状态。当获取到两只筷子后，就可以开始吃饭了，吃饭结束后释放筷子，并通知其他小朋友。通过这种方式，保证了每个小朋友都能成功吃饭。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:27:27 | 显示全部楼层
@FishC1代码错误进行修改
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:27:49 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:27
@FishC1代码错误进行修改


下面是修改后的代码：

  1. public class DiningProblem {

  3.     // 筷子的使用情况，true代表筷子可用，false代表筷子被占用
  4.     private static boolean[] forks = {true, true, true, true, true};

  6.     public static void main(String[] args) {
  7.         // 创建5个小朋友
  8.         for (int i = 0; i < 5; i++) {
  9.             new Thread(new LittleFriend(i)).start();
  10.         }
  11.     }

  13.     // 小朋友类
  14.     static class LittleFriend implements Runnable {
  15.         private int id;
  16.         private int leftFork;
  17.         private int rightFork;

  19.         public LittleFriend(int id) {
  20.             this.id = id;
  21.             this.leftFork = id;
  22.             this.rightFork = (id + 1) % 5;
  23.         }

  25.         // 吃饭方法
  26.         public void eating() {
  27.             synchronized (forks) {
  28.                 // 当左右手的筷子都未被使用时才能获取筷子
  29.                 while (!forks[leftFork] || !forks[rightFork]) {
  30.                     try {
  31.                         forks.wait();
  32.                     } catch (InterruptedException e) {
  33.                         e.printStackTrace();
  34.                     }
  35.                 }

  37.                 // 获取筷子
  38.                 forks[leftFork] = false;
  39.                 forks[rightFork] = false;
  40.             }

  42.             // 吃饭时间
  43.             System.out.println("第" + id + "位小朋友正在吃饭");

  45.             // 吃完饭后释放筷子
  46.             putFork();
  47.         }

  49.         // 放下筷子方法
  50.         public void putFork() {
  51.             synchronized (forks) {
  52.                 forks[leftFork] = true;
  53.                 forks[rightFork] = true;
  54.                 forks.notifyAll();
  55.             }
  56.             // 继续玩耍
  57.             playing();
  58.         }

  60.         // 玩耍方法
  61.         public void playing() {
  62.             System.out.println("第" + id + "位小朋友正在玩耍");

  64.             try {
  65.                 // 模拟玩耍过程
  66.                 Thread.sleep((int) (Math.random() * 1000));
  67.             } catch (InterruptedException e) {
  68.                 e.printStackTrace();
  69.             }

  71.             // 进入下一轮吃饭
  72.             eating();
  73.         }

  75.         @Override
  76.         public void run() {
  77.             eating();
  78.         }
  79.     }
  80. }
复制代码


这个代码通过使用同步锁和wait/notify机制来确保每个小朋友能够成功拿到两只筷子进行就餐。每个小朋友先尝试获取左右两只筷子，如果有一只或两只筷子已经被其他小朋友拿走，则当前小朋友进入等待状态。当两只筷子都可用时，小朋友开始吃饭，吃完后放下筷子并继续玩耍。整个过程通过循环调用eating和playing方法保证了小朋友们能够持续进行就餐和玩耍的交替。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:33:34 | 显示全部楼层
@FishC1对该代码按要求进行修改(1)        查看运行结果分析后，每个小朋友相当于一个线程，所以先创建一个Littlefriend()方法作为小朋友。
(2)        查看运行结果分析后，创建eating()方法作为小朋友吃饭时的线程，创建playing()方法作为小朋友玩耍时的线程。
(3)        查看运行结果分析后，需要在获取筷子的方法Fork中先定义一个boolean类型的数组，代表5根筷子的使用情况；再使用synchronized线程锁来控制只有左右手的筷子都未被使用时，才允许获取筷子，且必须同时获取左右手筷子。
(4)        查看运行结果分析后，需要在释放左右手筷子的方法putFork中使用synchronized线程锁来释放筷子。
(5)        最后在测试类中调用5次以上方法，代表5位小朋友。
  1. 小朋友相当于一个线程
  2. class Child extends Thread{
  3.     private String name;
  4.     private Chopsticks chopsticks;
  5.     public Child(String name,Chopsticks chopsticks){
  6.         super(name);
  7.         this.name=name;
  8.         this.chopsticks=chopsticks;
  9.     }
  10.     public void run(){
  11.         while(true){
  12.             playing();
  13.             chopsticks.takeChopsticks();
  14.             eating();
  15.             chopsticks.putChopsticks();
  16.         }
  17.     }
  18.     public void eating(){
  19.         System.out.println("小朋友"+name+"在吃饭");
  20.         try {
  21.             sleep(1000);//模拟吃饭，占用一段时间
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26.     public void playing(){
  27.         System.out.println("小朋友"+name+"在玩游戏");
  28.         try {
  29.             sleep(1000);//模拟玩耍，占用一段时间
  30.         } catch (InterruptedException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }
  35. class Chopsticks{
  36.     //5只筷子，初始为都未被用
  37.     private boolean[] used={false,false,false,false,false};
  38.     //只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  39.     public synchronized void takeChopsticks(){
  40. //请完善程序，获得当前小朋友线程的名字
  41.         String name =Thread.currentThread().getName();
  42.         //请完善程序，获得当前小朋友线程的名字所对应的整数值
  43.         int i =Integer.parseInt(name);
  44. //请完善程序中的条件，判定当前小朋友左右的筷子是否都未被占用，否则等待
  45.         while(used[i]||used[(i+1)%5]){
  46.             try {
  47.                 wait();//如果左右手有一只正被使用，等待
  48.             } catch (InterruptedException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }

  53.         used[i ]= true;
  54.         used[(i+1)%5]=true;
  55.     }
  56.     /*必须同时释放左右手的筷子*/
  57.     public synchronized void putChopsticks(){
  58.         String name = Thread.currentThread().getName();
  59.         int i = Integer.parseInt(name);
  60. //请完善程序，将当前小朋友左右的筷子状态更新为未被占用
  61.         used[i]=false;
  62.         used[(i+1)%5]=false;

  64. //请完善程序，唤醒所有正在等待的小朋友线程
  65.         notifyAll();
  66.     }
  67. }
  68. class Test {
  69.     public static void main(String []args){
  70.         Chopsticks chopsticks = new Chopsticks();
  71.         new Child("0",chopsticks).start();
  72. //请完善程序，再依次生成四个小朋友线程并启动
  73.         new Child("1",chopsticks).start();
  74.         new Child("2",chopsticks).start();
  75.         new Child("3",chopsticks).start();
  76.         new Child("4",chopsticks).start();

  78.     }
  79. }


复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:33:58 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:33
@FishC1对该代码按要求进行修改(1)        查看运行结果分析 ...


下面是根据要求修改后的代码：

  1. class Child extends Thread{
  2.     private String name;
  3.     private Chopsticks chopsticks;
  4.    
  5.     public Child(String name, Chopsticks chopsticks){
  6.         super(name);
  7.         this.name = name;
  8.         this.chopsticks = chopsticks;
  9.     }
  10.    
  11.     public void run(){
  12.         while(true){
  13.             playing();
  14.             chopsticks.takeChopsticks();
  15.             eating();
  16.             chopsticks.putChopsticks();
  17.         }
  18.     }
  19.    
  20.     public void eating(){
  21.         System.out.println("小朋友" + name + "在吃饭");
  22.         try {
  23.             sleep(1000); // 模拟吃饭，占用一段时间
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28.    
  29.     public void playing(){
  30.         System.out.println("小朋友" + name + "在玩游戏");
  31.         try {
  32.             sleep(1000); // 模拟玩耍，占用一段时间
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

  39. class Chopsticks{
  40.     // 5只筷子，初始为都未被用
  41.     private boolean[] used = {false, false, false, false, false};
  42.    
  43.     // 只有当左右的筷子都未被使用时，才允许获取筷子，且必须同时获取左右筷子
  44.     public synchronized void takeChopsticks(){
  45.         int left = Integer.parseInt(Thread.currentThread().getName());
  46.         int right = (left + 1) % 5;
  47.         
  48.         while(used[left] || used[right]){
  49.             try {
  50.                 wait(); // 如果左右手有一只已被使用，等待
  51.             } catch (InterruptedException e) {
  52.                 e.printStackTrace();
  53.             }
  54.         }
  55.         
  56.         used[left] = true;
  57.         used[right] = true;
  58.     }
  59.    
  60.     /*必须同时释放左右手的筷子*/
  61.     public synchronized void putChopsticks(){
  62.         int left = Integer.parseInt(Thread.currentThread().getName());
  63.         int right = (left + 1) % 5;
  64.         
  65.         used[left] = false;
  66.         used[right] = false;
  67.         
  68.         notifyAll(); // 唤醒所有正在等待的小朋友线程
  69.     }
  70. }

  72. class Test {
  73.     public static void main(String[] args){
  74.         Chopsticks chopsticks = new Chopsticks();
  75.         
  76.         for(int i = 0; i < 5; i++){
  77.             new Child(String.valueOf(i), chopsticks).start();
  78.         }
  79.     }
  80. }
复制代码


这段代码通过创建`Child`类来表示每个小朋友的线程。`Child`类中的`eating()`方法模拟吃饭过程，`playing()`方法模拟玩耍过程。`Chopsticks`类表示筷子，其中的`takeChopsticks()`方法负责获取筷子，`putChopsticks()`方法负责释放筷子。`Test`类用于启动多个小朋友线程。

运行该程序，你会看到每个小朋友交替地进行吃饭和玩耍，确保每个小朋友都能成功就餐。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

卷帘红尘亦爱她
 楼主| 发表于 2024-4-15 19:46:40 | 显示全部楼层
@FishC1一圆桌前坐着5位小朋友，两个人中间有一只筷子，桌子中央有面条。小朋友边吃边玩，当饿了的时候拿起左右两只筷子吃饭，必须拿到两只筷子才能吃饭。但是，小朋友在吃饭过程中，可能会发生5个小朋友都拿起自己右手边的筷子，这样每个小朋友都因缺少左手边的筷子而没有办法吃饭。本案例要求编写一个程序解决小朋友就餐问题，使每个小朋友都能成功就餐。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-4-15 19:47:03 | 显示全部楼层
卷帘红尘亦爱她 发表于 2024-04-15 19:46
@FishC1一圆桌前坐着5位小朋友，两个人中间有一只筷子 ...


下面是根据要求编写的代码：

  1. class Child extends Thread{
  2.     private String name;
  3.     private Chopsticks leftChopstick;
  4.     private Chopsticks rightChopstick;
  5.    
  6.     public Child(String name, Chopsticks leftChopstick, Chopsticks rightChopstick){
  7.         this.name = name;
  8.         this.leftChopstick = leftChopstick;
  9.         this.rightChopstick = rightChopstick;
  10.     }
  11.    
  12.     public void run(){
  13.         while(true){
  14.             playing();
  15.             
  16.             synchronized(leftChopstick){
  17.                 synchronized(rightChopstick){
  18.                     eating();
  19.                 }
  20.             }
  21.         }
  22.     }

  24.     public void eating(){
  25.         System.out.println("小朋友" + name + "在吃饭");
  26.         try {
  27.             Thread.sleep(1000);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }

  33.     public void playing(){
  34.         System.out.println("小朋友" + name + "在玩耍");
  35.         try {
  36.             Thread.sleep(1000);
  37.         } catch (InterruptedException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41. }

  43. class Chopsticks{
  44.     private boolean used = false;
  45.    
  46.     public synchronized void takeChopstick(){
  47.         while(used){
  48.             try {
  49.                 wait();
  50.             } catch (InterruptedException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.         
  55.         used = true;
  56.     }
  57.    
  58.     public synchronized void putChopstick(){
  59.         used = false;
  60.         notifyAll();
  61.     }
  62. }

  64. public class Test {
  65.     public static void main(String[] args){
  66.         Chopsticks[] chopsticks = new Chopsticks[5];
  67.         for(int i = 0; i < 5; i++){
  68.             chopsticks[i] = new Chopsticks();
  69.         }
  70.         
  71.         Child[] children = new Child[5];
  72.         for(int i = 0; i < 5; i++){
  73.             // 每个小朋友的左手边筷子编号为i，右手边筷子编号为(i+1)%5
  74.             children[i] = new Child(String.valueOf(i), chopsticks[i], chopsticks[(i+1)%5]);
  75.             children[i].start();
  76.         }
  77.     }
  78. }
复制代码


在上面的代码中，每个小朋友线程持有一个左手边和右手边的筷子对象，通过`synchronized`关键字实现对筷子的互斥访问，避免多个小朋友同时拿到同一只筷子导致死锁的问题。这样，每个小朋友都能成功地拿到两只筷子进行就餐。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

123456789
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-5-2 13:09

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表