首页 > 代码库 > 黑马程序员——餐桌上的多线程问题

黑马程序员——餐桌上的多线程问题

2024-07-04 12:46:15   222人阅读

餐桌上的多线程问题

生产者和消费者模型

         设想有一天你和一群朋友去餐馆吃饭，这是个典型的同步例子，你和你的朋友们共享着餐桌这个资源。想象一下，当你举起筷子准备夹菜的时候，却发现菜碟子被人端走了~这正是同步要解决的问题，必须保证在某人夹菜的时候，其他人不能把菜盘子端走。Java中使用加锁的机制，使用Synchronized来保证代码执行的时候不受共享资源的其他人的干扰。
     而餐厅的服务员根据你的订单给你上菜，当菜吃完了通知服务员给你们上菜，这又是个典型的生产者消费者模型。下面用内部类简单实现下这个问题。
 
package moreCoding1;
class Person {
          String name;
          Person ( String name){
                    this. name= name;
           }
}
class Shop{
           private Person
           p1= new Person( "服务员" ),
           p2= new Person( "张三" ),     
           p3= new Person( "李四" );     
           private boolean flag= false;
          Thread thread1= new Thread( new Runnable(){
                    public void run () {
                              while (true ){
                                       while (flag == true){
                                                 try {
                                                          wait ();
                                                 } catch (Exception e ) {
                                                 }
                                       }
                                       synchronized ( this ) {
                                                System . out. println( p1. name+ "上了" +">>>" +1 +"个菜" );
                                                 flag= true;
                                                notifyAll ();
                                       } }}}) ;
          Thread thread2= new Thread( new Runnable(){
                    public void run () {
                              while (true ){
                                       while (flag == false){
                                                 try {
                                                          wait ();
                                                 } catch (Exception e ) {
                                                 }
                                       }
                                       synchronized ( this ) {
                                                System . out. println( p2. name+ "吃了" +"<<<<" +1 +"个菜" );
                                                 flag= false;
                                                notifyAll ();
                                       } }}}) ;
          Thread thread3= new Thread( new Runnable(){
                    public void run () {
                              // TODO Auto-generated method stub
                              while (true ){
                                       while (flag == false){
                                                 try {
                                                          wait ();
                                                 } catch (Exception e ) {
                                                 }}
                                       synchronized ( this ) {
                                                System . out. println( p3. name+ "吃了" +"~~~~" +1 +"个菜" );
                                                 flag= false;
                                                notifyAll ();
                                       } }}}) ;
          Shop (){
                    thread1. start ();
                    thread2. start ();
                    thread3. start ();
           }
}
public class MyThread {
public static void main ( String[] args ) {
           new Shop() ;
}
}
//
/*张三吃了<<<<1个菜
服务员上了>>>1个菜
张三吃了<<<<1个菜
服务员上了>>>1个菜
李四吃了~~~~1个菜
服务员上了>>>1个菜
李四吃了~~~~1个菜
服务员上了>>>1个菜
李四吃了~~~~1个菜*/
死锁

     假如发生了这样的问题，筷子不够，筷子的跟数只有你们人数那么多，那么每个人吃饭都要先拿左手的筷子，然后再设法拿到右边的筷子，当你发现每个人左手都拿着筷子等右边的筷子的时候，死锁就产生了。


联系
我们