26 多线程04生产者和消费者问题Object类中对线程的支持以及面试题目.docx

26 多线程04生产者和消费者问题Object类中对线程的支持以及面试题目.docx

《26 多线程04生产者和消费者问题Object类中对线程的支持以及面试题目.docx》由会员分享，可在线阅读，更多相关《26 多线程04生产者和消费者问题Object类中对线程的支持以及面试题目.docx（21页珍藏版）》请在冰豆网上搜索。

26多线程04生产者和消费者问题Object类中对线程的支持以及面试题目

26.多线程（04）

本季讲解了线程通讯的经典案例，之后又讲解了Object类中对线程的支持，以及面试题目。

blog:

[零基础学JAVA]JavaSE应用部分-26.多线程（04）2009-02-19

生产者和消费者问题

（1）

生产者和消费者问题

（2）

class Person{    

        Stringname= "张三";    

        Stringsex= "男";    

        //张三-->男    

        //李四-->女    

}    

class Pro implements Runnable{    

        //声明一个共享区域    

        Personper= null;    

        public Pro（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                int i=0;    

                while（true）{    

                        if （i==0）{    

                                per.name= "李四";    

                                per.sex= "女";    

                                i=1;    

                        }else{    

                                per.name= "张三";    

                                per.sex= "男";    

                                i=0;    

                        }    

                }    

        }    

}    

class Cus implements Runnable{    

        Personper= null;    

        public Cus（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                while（true）{    

                        System.out.println（per.name+"-->"+per.sex）;    

                }    

        }    

}    

public class ThreadDemo01{    

        public static void main（Stringargs[]）{    

                Personper= new Person（）;    

                Prop= new Pro（per）;    

                Cusc= new Cus（per）;    

                new Thread（p）.start（）;    

                new Thread（c）.start（）;    

        }    

}

看下效果：

以上代码已经可以从输出中看见了一些错误了，所以此处我们可以将代码进行修改，加入一些延迟，这样错误比较明显了

class Person{    

        Stringname= "张三";    

        Stringsex= "男";    

        //张三-->男    

        //李四-->女    

}    

class Pro implements Runnable{    

        //声明一个共享区域    

        Personper= null;    

        public Pro（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                int i=0;    

                while（true）{    

                        if （i==0）{    

                                per.name= "李四";    

                                try{    

                                        Thread.sleep（100）;    

                                }catch （Exceptione）{}    

                                per.sex= "女";    

                                i=1;    

                        }else{    

                                per.name= "张三";    

                                per.sex= "男";    

                                i=0;    

                        }    

                }    

        }    

}    

class Cus implements Runnable{    

        Personper= null;    

        public Cus（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                while（true）{    

                        try{    

                                        Thread.sleep（100）;    

                                }catch （Exceptione）{}    

                        System.out.println（per.name+"-->"+per.sex）;    

                }    

        }    

}    

public class ThreadDemo02{    

        public static void main（Stringargs[]）{    

                Personper= new Person（）;    

                Prop= new Pro（per）;    

                Cusc= new Cus（per）;    

                new Thread（p）.start（）;    

                new Thread（c）.start（）;    

        }    

}

之前的两个问题已经全部出现了，现在解决第一个：

关于设置内容的问题； 

·永远要保持张三是男，李四是女。

class Person{    

        private Stringname= "张三";    

        private Stringsex= "男";    

        //张三-->男    

        //李四-->女    

        public synchronized void set（Stringname,Stringsex）{    

                this.name=name;    

                //加入延迟验证设置是否生效    

                try{    

                        Thread.sleep（100）;    

                }catch （Exceptione）{}    

                this.sex=sex;    

        }    

        //设置一个输出方法    

        public synchronized void get（）{    

                try{    

                        Thread.sleep（100）;    

                }catch （Exceptione）{}    

                System.out.println（this.name+"-->"+this.sex）;    

        }    

}    

class Pro implements Runnable{    

        //声明一个共享区域    

        Personper= null;    

        public Pro（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                int i=0;    

                while（true）{    

                        if （i==0）{    

                                per.set（"李四","女"）;    

                                i=1;    

                        }else{    

                                per.set（"张三","男"）;    

                                i=0;    

                        }    

                }    

        }    

}    

class Cus implements Runnable{    

        Personper= null;    

        public Cus（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                while（true）{    

                        per.get（）;    

                }    

        }    

}    

public class ThreadDemo03{    

        public static void main（Stringargs[]）{    

                Personper= new Person（）;    

                Prop= new Pro（per）;    

                Cusc= new Cus（per）;    

                new Thread（p）.start（）;    

                new Thread（c）.start（）;    

        }    

}

通过同步方法，确实解决了设置上的问题，张三是男的，李四是女的，但是第二个问题还没有解决，以上效果看到得只是假像，如果休眠时间设置都取消的话可以看出问题哈~

class Person{    

        private Stringname= "张三";    

        private Stringsex= "男";    

        //张三-->男    

        //李四-->女    

        public synchronized void set（Stringname,Stringsex）{    

                this.name=name;    

                //加入延迟验证设置是否生效    

                this.sex=sex;    

        }    

        //设置一个输出方法    

        public synchronized void get（）{    

                System.out.println（this.name+"-->"+this.sex）;    

        }    

}    

class Pro implements Runnable{    

        //声明一个共享区域    

        Personper= null;    

        public Pro（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                int i=0;    

                while（true）{    

                        if （i==0）{    

                                per.set（"李四","女"）;    

                                i=1;    

                        }else{    

                                per.set（"张三","男"）;    

                                i=0;    

                        }    

                }    

        }    

}    

class Cus implements Runnable{    

        Personper= null;    

        public Cus（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                while（true）{    

                        per.get（）;    

                }    

        }    

}    

public class ThreadDemo04{    

        public static void main（Stringargs[]）{    

                Personper= new Person（）;    

                Prop= new Pro（per）;    

                Cusc= new Cus（per）;    

                new Thread（p）.start（）;    

                new Thread（c）.start（）;    

        }    

}

如果设置成只有一个休眠中断的话看得明显

class Person{    

        private Stringname= "张三";    

        private Stringsex= "男";    

        //张三-->男    

        //李四-->女    

        public synchronized void set（Stringname,Stringsex）{    

                this.name=name;    

                //加入延迟验证设置是否生效    

                this.sex=sex;    

        }    

        //设置一个输出方法    

        public synchronized void get（）{    

                System.out.println（this.name+"-->"+this.sex）;    

        }    

}    

class Pro implements Runnable{    

        //声明一个共享区域    

        Personper= null;    

        public Pro（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                int i=0;    

                while（true）{    

                        if （i==0）{    

                                per.set（"李四","女"）;    

                                i=1;    

                        }else{    

                                per.set（"张三","男"）;    

                                i=0;    

                        }    

                }    

        }    

}    

class Cus implements Runnable{    

        Personper= null;    

        public Cus（Personp）{    

                this.per=p;    

        }    

        public void run（）{    

                while（true）{    

                        try    

                        {    

                                Thread.sleep（500）;    

                        }    

                        catch （Exceptione）    

                        {    

                        }    

                        per.get（）;    

                }    

        }    

}    

public class ThreadDemo04{    

        public static void main（Stringargs[]）{    

                Personper= new Person（）;    

                Prop= new Pro（per）;    

                Cusc= new Cus（per）;    

                new Thread（p）.start（）;    

                new Thread（c）.start（）;    

        }    

}

如果不让其重复取值，我们可以学习下下面的知识

绿灯可以放数据，不能取数据

红灯可以取数据，不能放数据

同理依次执行哈~

如果红灯时，即消费者（read）取数据时，CPU将资源给了生产者，当生产者将数据要放入时，发现是红灯，只能等待哈~

等到绿灯时生产者才能将cccc数据放入哈~

这样的机制就是线程的等待和唤醒，也就是下面的内容哈~

线程的等待及唤醒

当发现消费者没有取走内容的时候，生产者应该等待 

当消费者把内容取走之后，生产者才可以放。

class Person{    

        private Stringname= "张三";    

        private Stringsex= "男";    

        private boolean flag= false;    

        //flag=true时表示允许生产但