[零基础学JAVA]Java SE应用部分-26.多线程（04）

生产者和消费者问题（1）

生产者和消费者问题（2）

class Person{    
        String name = "张三";    
        String sex = "男";    
         // 张三 --> 男    
         // 李四 --> 女    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 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{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                        System.out.println(per.name+ " --> "+per.sex);    
                }    
        }    
}    
public class ThreadDemo01{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

看下效果：

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

class Person{    
        String name = "张三";    
        String sex = "男";    
         // 张三 --> 男    
         // 李四 --> 女    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 int i = 0;    
                 while( true){    
                         if (i==0){    
                                per.name = "李四";    
                                 try{    
                                        Thread.sleep(100);    
                                } catch (Exception e){}    
                                per.sex = "女";    
                                i=1;    
                        } else{    
                                per.name = "张三";    
                                per.sex = "男";    
                                i =0;    
                        }    
                }    
        }    
}    
class Cus implements Runnable{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                         try{    
                                        Thread.sleep(100);    
                                } catch (Exception e){}    
                        System.out.println(per.name+ " --> "+per.sex);    
                }    
        }    
}    
public class ThreadDemo02{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

之前的两个问题已经全部出现了，现在解决第一个：关于设置内容的问题；
· 永远要保持张三是男，李四是女。

class Person{    
         private String name = "张三";    
         private String sex = "男";    
         // 张三 --> 男    
         // 李四 --> 女    
         public synchronized void set(String name,String sex){    
                 this.name = name;    
                 // 加入延迟验证设置是否生效    
                 try{    
                        Thread.sleep(100);    
                } catch (Exception e){}    
                 this.sex = sex;    
        }    
         //设置一个输出方法    
         public synchronized void get(){    
                 try{    
                        Thread.sleep(100);    
                } catch (Exception e){}    
                System.out.println( this.name+ " --> "+ this.sex);    
        }    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 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{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                        per.get();    
                }    
        }    
}    
public class ThreadDemo03{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

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

class Person{    
         private String name = "张三";    
         private String sex = "男";    
         // 张三 --> 男    
         // 李四 --> 女    
         public synchronized void set(String name,String sex){    
                 this.name = name;    
                 // 加入延迟验证设置是否生效    
                 this.sex = sex;    
        }    
         //设置一个输出方法    
         public synchronized void get(){    
                System.out.println( this.name+ " --> "+ this.sex);    
        }    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 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{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                        per.get();    
                }    
        }    
}    
public class ThreadDemo04{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

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

class Person{    
         private String name = "张三";    
         private String sex = "男";    
         // 张三 --> 男    
         // 李四 --> 女    
         public synchronized void set(String name,String sex){    
                 this.name = name;    
                 // 加入延迟验证设置是否生效    
                 this.sex = sex;    
        }    
         //设置一个输出方法    
         public synchronized void get(){    
                System.out.println( this.name+ " --> "+ this.sex);    
        }    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 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{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                         try    
                        {    
                                Thread.sleep(500);    
                        }    
                         catch (Exception e)    
                        {    
                        }    
                        per.get();    
                }    
        }    
}    
public class ThreadDemo04{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

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

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

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

同理依次执行哈~

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

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

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

线程的等待及唤醒

当发现消费者没有取走内容的时候，生产者应该等待
当消费者把内容取走之后，生产者才可以放。

class Person{    
         private String name = "张三";    
         private String sex = "男";    
         private boolean flag = false;    
         // flag = true时表示允许生产但不允许取走    
         // flag = false时表示允许取走但不允许生产    
         // 张三 --> 男    
         // 李四 --> 女    
         //编写一个设置内容的方法    
         public synchronized void set(String name,String sex){    
                 //如果flag的值不是true则要等待    
                 if (!flag){    
                         //等待    
                         try{    
                                wait();    
                        } catch(Exception e){}    
                }    
                 try{    
                        Thread.sleep(100);    
                } catch (Exception e){}    
                 // 如果向下继续执行了，则表示可以设置,flag = true    
                 this.name = name;    
                 this.sex = sex;    
                 // 修改设置的标志    
                flag = false;    
                 //唤醒其他线程    
                notify();    
        }    
         //设置一个输出方法    
         public synchronized void get(){    
                 // 如果flag的值为true的时候，表示要等待    
                 if(flag){    
                         try{    
                                wait();    
                        } catch(Exception e){}    
                }    
                 try{    
                        Thread.sleep(100);    
                } catch (Exception e){}    
                 //如果向下执行了，则表示允许取出    
                System.out.println( this.name+ " --> "+ this.sex);    
                 //改变标志，表示可以生产了    
                flag = true;    
                notify();    
        }    
}    
class Pro implements Runnable{    
         //声明一个共享区域    
        Person per = null;    
         public Pro(Person p){    
                 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{    
        Person per = null;    
         public Cus(Person p){    
                 this.per = p;    
        }    
         public void run(){    
                 while( true){    
                        per.get();    
                }    
        }    
}    
public class ThreadDemo05{    
         public static void main(String args[]){    
                Person per = new Person();    
                Pro p = new Pro(per);    
                Cus c = new Cus(per);    
                 new Thread(p).start();    
                 new Thread(c).start();    
        }    
}

看下效果：这样就解决了第二个问题

 

以上的三个方法，实际上是Object类中的三个方法。

控制线程的生命周期

以上的很多方法都不建议继续使用了，因为会造成死锁，那么如果我现在要停止一个线程的运行，该怎么办？
C盘拷贝内容到D盘，中止拷贝时系统会有些延迟，同理我们可以通过设置标志位让其停止。

class MyThread implements Runnable{    
         private boolean flag = true;    
         public void run(){    
                 int i=0;    
                 while(flag){    
                        System.out.println(Thread.currentThread().getName()+ " --> 运行，i ="+(i++));    
                }    
        }    
         public void setFlag( boolean flag){    
                 this.flag = flag;    
        }    
}    
public class ThreadDemo06{    
         public static void main(String args[]){    
                MyThread mt = new MyThread();    
                 new Thread(mt).start();    
                 try{    
                        Thread.sleep(300);    
                } catch(Exception e){}                
                 //将线程的运行的条件修改了，则肯定停止运行    
                mt.setFlag( false);    
        }    
}

或者也可以修改成 throws Exception

class MyThread implements Runnable{    
         private boolean flag = true;    
         public void run(){    
                 int i=0;    
                 while(flag){    
                        System.out.println(Thread.currentThread().getName()+ " --> 运行，i ="+(i++));    
                }    
        }    
         public void setFlag( boolean flag){    
                 this.flag = flag;    
        }    
}    
public class ThreadDemo06{    
         public static void main(String args[]) throws Exception{    
                MyThread mt = new MyThread();    
                 new Thread(mt).start();    
                Thread.sleep(300);    
                 //将线程的运行的条件修改了，则肯定停止运行    
                mt.setFlag( false);    
        }    
}

发现程序运行一段时间后自己停止运行了哈~~~

多线程面试题：

 

可以直接参考生产者和消费者问题。

class Num{    
         int j = 0;    
}    
class Inc implements Runnable{    
         private Num n = null;    
         public Inc(Num n){    
                 this.n = n;    
        }    
         public void run(){    
                 while( true){    
                        System.out.println( "加："+Thread.currentThread().getName()+ " -->"+n.j++);    
                }    
        }    
}    
class Dec implements Runnable{    
         private Num n = null;    
         public Dec(Num n){    
                 this.n = n;    
        }    
         public void run(){    
                 while( true){    
                        System.out.println( "减："+Thread.currentThread().getName()+ " -->"+n.j--);    
                }    
        }    
}    
public class ThreadDemo07{    
         public static void main(String args[]){    
                Num n = new Num();    
                Inc i = new Inc(n);    
                Dec d = new Dec(n);    
                 new Thread(i, "加线程A:").start();    
                 new Thread(i, "加线程B:").start();    
                 new Thread(d, "减线程C:").start();    
                 new Thread(d, "减线程D:").start();    
        }    
}

看下效果：

 

本季重点：

使用Runnable可以实现资源的共享，但是实现之后就必须想办法对资源进行同步，否则会出现数据不正确的情况，但是如果过多的使用了同步，则会发生死锁。

完整的方法定义：
[public|protected|default|private] [synchronized] [static] [final]
返回值类型|void 方法名称(参数列表) [throws 异常]

#############################################################