/**
线程之间的通信
*/
// 定义共享资源
class ShareSource
{
public boolean tag = true;
}
// 定义线程你
class You extends Thread
{
    ShareSource s = null;
public You(){

}
    public You( ShareSource s , String name ){
   super(name);
   this.s = s;
}
   
public void run(){
    // 说话
      synchronized( s ){
        while(true){
     if( !s.tag ){
     // 你不说话，等待
             try
             {
     s.wait();
             }
             catch (InterruptedException e)
             {
             }
   
     }
     // 你说话
           System.out.println( this.getName()+"说：\" 你好，这些年的过的好吗？\" ");
     // 设置标记
     s.tag = false;
     // 通知
     s.notify();
        }
      }
}
}
class Me extends Thread
{
    ShareSource s = null;
public Me(){

}
    public Me( ShareSource s , String name ){
   super(name);
   this.s = s;
}
    public void run(){
    synchronized(s){
      while(true){
    // 说话
    if( s.tag ){
      // 我不说话，我等待
    try
             {
     s.wait();
             }
             catch (InterruptedException e)
             {
             }
    }
    // 我说话
    System.out.println( this.getName()+"说：\"你好，这些我过的还可以!\" ");
    // 设置标记
    s.tag = true;
    // 通知
    s.notify();
      }
     }
}
}
class Demo12
{
public static void main(String[] args)
{
  // 创建资源对象
        ShareSource s = new ShareSource();
  new Me( s, "me" ).start();
  new You( s, "you" ).start();
  // System.out.println("Hello World!");
}
}
疑惑：
  请问 这个锁该如何设置？
     有什么规定的吗？ 怎么样锁？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
所以同步函数使用的锁是this。


就是同步代码快。

synchronized（对象）｛
          需要被同步的代码（看那些代码参与共享数据）
          ｝
对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
1.必须要有两个或者两个以上的线程。
2.必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。
如果同步函数被静态修饰后，他的锁就不是this了。
当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清楚。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
thread类提供该方法就是 interrupt（）；

你这里很明显是用的同步代码块，而同步代码块用的锁，可以是this，
也可以是字节码文件运行时的类，亦可以自己来定义一个锁，但是
必须保证所有操作共享数据的线程用的是同一把锁。

同步函数被静态修饰  ，它不可能用的是this，因为this需要对象，
而对象是通过类创建的，所以是类.class即  .class文件被加载到内存中的字节码文件