本章目标
1）加深对线程同步的理解
2）了解Object类中对线程的支持方法。
实例
生产者不断生产，消费者不断消费产品。
生产者生产信息后将其放到一个区域中，之后消费者从区域中取出数据。
既然生产的是信息，就可以定义一个信息的表示类，生产者和消费者同时占有信息类的引用，那么就可以将生产者和消费者两个线程通过信息类联合在一起。
如下：
class Info{ // 定义信息类 private String name = "李兴华"; // 定义name属性 private String content = "JAVA讲师" ; public void setName(String name){ this.name = name ; } public void setContent(String content){ this.content = content ; } public String getName(){ return this.name ; } public String getContent(){ return this.content ; } };
建立生产者类，生产者实现多线程机制。
class Producer implements Runnable{ // 通过Runnable实现多线程 private Info info = null ; // 保存Info引用 public Producer(Info info){ this.info = info ; } public void run(){ boolean flag = false ; // 定义标记位 for(int i=0;i<50;i++){ if(flag){ this.info.setName("李兴华") ; // 设置名称 try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } this.info.setContent("JAVA讲师") ; // 设置内容 flag = false ; }else{ this.info.setName("mldn") ; // 设置名称 try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } this.info.setContent("www.mldnjava.cn") ; // 设置内容 flag = true ; } } } };
生产者生产50次信息，中间为了更好的发现问题，加入了延迟操作。
实现消费者，消费者要不断取出。
class Consumer implements Runnable{ private Info info = null ; public Consumer(Info info){ this.info = info ; } public void run(){ for(int i=0;i<50;i++){ try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } System.out.println(this.info.getName() + " --> " + this.info.getContent()) ; } } };
最后完整代码如下
class Info{ // 定义信息类 private String name = "李兴华"; // 定义name属性 private String content = "JAVA讲师" ; public void setName(String name){ this.name = name ; } public void setContent(String content){ this.content = content ; } public String getName(){ return this.name ; } public String getContent(){ return this.content ; } }; class Producer implements Runnable{ // 通过Runnable实现多线程 private Info info = null ; // 保存Info引用 public Producer(Info info){ this.info = info ; } public void run(){ boolean flag = false ; // 定义标记位 for(int i=0;i<50;i++){ if(flag){ this.info.setName("李兴华") ; // 设置名称 try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } this.info.setContent("JAVA讲师") ; // 设置内容 flag = false ; }else{ this.info.setName("mldn") ; // 设置名称 try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } this.info.setContent("www.mldnjava.cn") ; // 设置内容 flag = true ; } } } }; class Consumer implements Runnable{ private Info info = null ; public Consumer(Info info){ this.info = info ; } public void run(){ for(int i=0;i<50;i++){ try{ Thread.sleep(90) ; }catch(InterruptedException e){ e.printStackTrace() ; } System.out.println(this.info.getName() + " --> " + this.info.getContent()) ; } } }; public class ThreadCaseDemo01{ public static void main(String args[]){ Info info = new Info(); // 实例化Info对象 Producer pro = new Producer(info) ; // 生产者 Consumer con = new Consumer(info) ; // 消费者 new Thread(pro).start() ; new Thread(con).start() ; } };
运行结果如下：
李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> JAVA讲师 mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> JAVA讲师 mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn mldn --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> JAVA讲师 李兴华 --> www.mldnjava.cn 李兴华 --> JAVA讲师
以上结果的红色部分可以看出，已经没有按照预先结果对应了，以上代码将之前的两个问题全部暴露出来。
之所以会出现内容不对应情况，是因为中间加入了延迟操作，所以有可能产生不同步的问题（参考上一章）。那么可以通过同步解决设置内容的问题。
通过同步操作修改后的内容。
class Info{ // 定义信息类 private String name = "李兴华"; private String content = "JAVA讲师" ; public synchronized void set(String name,String content){ this.setName(name) ; // 设置名称 try{ Thread.sleep(300) ; }catch(InterruptedException e){ e.printStackTrace() ; } this.setContent(content) ; // 设置内容 } public synchronized void get(){ try{ Thread.sleep(300) ; }catch(InterruptedException e){ e.printStackTrace() ; } System.out.println(this.getName() + " --> " + this.getContent()) ; } public void setName(String name){ this.name = name ; } public void setContent(String content){ this.content = content ; } public String getName(){ return this.name ; } public String getContent(){ return this.content ; } }; class Producer implements Runnable{ // 通过Runnable实现多线程 private Info info = null ; // 保存Info引用 public Producer(Info info){ this.info = info ; } public void run(){ boolean flag = false ; // 定义标记位 for(int i=0;i<50;i++){ if(flag){ this.info.set("李兴华","JAVA讲师") ; // 设置名称 flag = false ; }else{ this.info.set("mldn","www.mldnjava.cn") ; // 设置名称 flag = true ; } } } }; class Consumer implements Runnable{ private Info info = null ; public Consumer(Info info){ this.info = info ; } public void run(){ for(int i=0;i<50;i++){ this.info.get() ; } } }; public class ThreadCaseDemo02{ public static void main(String args[]){ Info info = new Info(); // 实例化Info对象 Producer pro = new Producer(info) ; // 生产者 Consumer con = new Consumer(info) ; // 消费者 new Thread(pro).start() ; new Thread(con).start() ; } };
运行结果如下：
李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 李兴华 --> JAVA讲师
以上的代码解决了数据完整性问题，但是依然存在重复取的问题，既然有重复取，则肯定有重复设置的问题，
并没有达到设置一个，取走一个的功能要求。
如果要想采用以上这种机制，则必须依靠Object类中的方法的支持。
Object类对线程的支持--等待与唤醒机制
Object类是所有类的父类，此类有以下几种方法是对线程操作有所支持的。
唤醒有两个方法：notify（）和notifyAll（）方法。
注意，因为Object是所有类的父类，所以其他类要想使用等待和唤醒，直接使用super即可，super调用父类方法。super.wait()；super.notify()；
notify()会唤醒第一个等待的线程，notifyAll（）会全部唤醒，那个线程优先级高哪个先执行。
注意wait()和notify()方法跟sleep（）方法一样，需要异常处理。
直接修改Info类即可，增加等待与唤醒的机制。
wait() ：
使当前线程等待直到另外一个线程调用了这个对象的Object的nofity()方法或者Object的notifyAll()方法。
复习synchronized知识可以参考：
java线程同步： synchronized详解（转）和
线程的同步与死锁
可以单这里：
Java 多线程详解（四）------生产者和消费者
wait():执行该方法的线程对象，释放同步锁，JVM会把该线程放到等待池中，等待其他线程唤醒该线程
notify():执行该方法的线程唤醒在等待池中等待的任意一个线程，把线程转到锁池中等待（注意锁池和等待池的区别）
notifyAll():执行该方法的线程唤醒在等待池中等待的所有线程，把线程转到锁池中等待。
注意：上述方法只能被同步监听锁对象来调用，这也是为啥wait() 和 notify()方法都在 Object 对象中，因为同步监听锁可以是任意对象，只不过必须是需要同步线程的共同对象即可，否则别的对象调用会报错： java.lang.IllegalMonitorStateException
假设 A 线程和 B 线程同时操作一个 X 对象，A，B 线程可以通过 X 对象的 wait() 和 notify() 方法来进行通信，流程如下：
①、当线程 A 执行 X 对象的同步方法时，A 线程持有 X 对象的 锁，B线程在 X 对象的锁池中等待
②、A线程在同步方法中执行 X.wait() 方法时，A线程释放 X 对象的锁，进入 X 对象的等待池中
③、在 X 对象的锁池中等待锁的 B 线程获得 X 对象的锁，执行 X 的另一个同步方法
④、B 线程在同步方法中执行 X.notify() 方法，JVM 把 A 线程从等待池中移动到 X 对象的锁池中，等待获取锁
⑤、B 线程执行完同步方法，释放锁，等待获取锁的 A 线程获得锁，继续执行同步方法
package Thread1; class Info{ // 定义信息类 private String name = "李兴华"; private String content = "JAVA讲师" ; //设置了默认值,使得消费者最开始就能消费。 private boolean flag = false ; // 设置标志位，默认为false，使得消费者能消费，生产者一开始就进入等待，直到消费者消费完唤醒它 public synchronized void set(String name,String content)throws InterruptedException{if(!flag){ 1 super.wait() ; 2 //如果flag为false，该进程进入等待，不往下进行，等待消费者消费完了，执行notify才能唤醒自己，继续下面的操作 } this.setName(name); 3 // 设置名称 Thread.sleep(300) ; this.setContent(content) ; // 设置内容 flag = false ; // 设置为false，目的是让调用本方法的线程不会第二次执行（第二次调用的时候就会把自己wait住，直到消费者消费完了，
才能唤醒自己，才能继续执行生产） super.notify() ; //生产完了，唤醒正在等待消费的消费者。 } public synchronized void get()throws InterruptedException{ if(flag){ super.wait() ; } Thread.sleep(300) ; System.out.println(this.getName() + " --> " + this.getContent()) ; flag = true ; // 改变标志位，表示可以生产 super.notify() ; } public void setName(String name){ this.name = name ; } public void setContent(String content){ this.content = content ; } public String getName(){ return this.name ; } public String getContent(){ return this.content ; } }; class Producer implements Runnable{ // 通过Runnable实现多线程 private Info info = null ; // 保存Info引用 public Producer(Info info){ this.info = info ; } public void run(){ boolean flag = false ; // 定义标记位 for(int i=0;i<50;i++){ try{ if(flag){ this.info.set("李兴华","JAVA讲师") ; // 设置名称 flag = false ; }else{ this.info.set("mldn","www.mldnjava.cn") ; // 设置名称 flag = true ; } }catch(InterruptedException e) //处理异常 { e.printStackTrace(); } } } }; class Consumer implements Runnable{ private Info info = null ; public Consumer(Info info){ this.info = info ; } public void run(){ for(int i=0;i<50;i++){ try{ this.info.get() ; }catch(InterruptedException e) //处理异常 { e.printStackTrace(); } } } }; public class demo1{ public static void main(String args[]){ Info info = new Info(); // 实例化Info对象 Producer pro = new Producer(info) ; // 生产者 Consumer con = new Consumer(info) ; // 消费者 new Thread(pro).start() ; new Thread(con).start() ; } };
运行结果：
李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn 李兴华 --> JAVA讲师 mldn --> www.mldnjava.cn
分析：
最开始设置Info对象的flag为false，使得生产者一进去就进入等待wait，消费者可以消费，此时消费者消费的是info对象默认值，消费完了设置flag为true，使得自己再次消费
的话，自己就进入等待（wait），等待生产者生产完告诉自己（唤醒它），然后告诉生产者可以开始生产了（唤醒生产者），此时等待中的生产者唤醒，获取锁，继续往下执行，生产完了后，flag设置为false，防止自己再次相生产的时候，可以把自己进入等待状态（直到消费者消费完告诉自己（唤醒自己）），然后告诉消费者，我生产完了，你可以开始消费了（唤醒消费者），此时等待中的消费者被唤醒，开始执行消费。。。循环。
此时等待的消费者开始继续
总结
1，在本程序中需要注意以下两种问题：
1）生产者要不断生产信息，但是不能重复生产，或者生产错误信息。
2）消费者要不断取走，但是不能重复取走。
2，Object类对线程的支持，等待wait()和nofity()和notifyAll(),注意异常的处理。
3，本道程序只是加深同步，等待，唤醒机制操作印象。