线程实现计时器，多线程间通信

Timer类:计时器

    public class Timer_Test {
        public static void main(String[] args) {
            new Timer().schedule(new Test(),new Date(),2000);
            while(true){
                System.out.println(new Date());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        static class Test extends TimerTask{
            @Override
            public void run() {
                System.out.println("时间到了");
            }
        }
    }

• schedule(TimerTask task, Date firstTime, long period)
  从指定 的时间开始 ，对指定的任务执行重复的 固定延迟执行 。

  三线程间通讯

• 在同步代码块中，用哪个对象锁，就用哪个对象调用wait方法。

  创建在Main方法中创建三个线程

• 代码

     public class Demoe {
         public static void main(String[] args) {
             Print p = new Print();
             new Thread() {
                 @Override
                 public void run() {
                     try {
                         while(true){
                             p.print1();
                         }
  
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }.start();
             new Thread() {
                 @Override
                 public void run() {
                     try {
                         while(true){
                             p.print2();
                         }
  
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }.start();
             new Thread() {
                 @Override
                 public void run() {
                     try {
                         while(true){
                             p.print3();
                         }
  
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }.start();
         }
  
         static class Print {                //创建内部类并创建三个成员方法，使用WAIT和NOTIFYALL实现线程等待和唤醒
             static int flag = 1;
  
             public void print1() throws InterruptedException {
                 synchronized (this) {
                     while (flag != 1) {    //使用wait保证判断语句能够执行，如果使用if将会直接唤醒线程而跳过判断阶段。
                         this.wait();
                     }
                     System.out.print("a");
                     System.out.print("b");
                     System.out.println();
                     flag = 2;
                     this.notifyAll();
                 }
             }
  
             public void print2() throws InterruptedException {
                 synchronized (this) {
                     while (flag != 2) {
                         this.wait();
                     }
                     System.out.print("1");
                     System.out.print("2");
                     System.out.println();
                     flag = 3;
                     this.notifyAll();
                 }
             }
  
             public void print3() throws InterruptedException {
                 synchronized (this) {
                     while (flag != 3) {
                         this.wait();
                     }
                     System.out.print("A");
                     System.out.println("B");
                     flag = 1;
                     this.notifyAll();
                 }
             }
  
         }
  
     }

• 多个线程通信的问题
  • notify()方法是随机唤醒一个线程
  • notifyAll()方法是唤醒所有线程
  • JDK5之前无法唤醒指定的一个线程
  • 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
• sleep方法与wait方法区别
  • sleep方法有参数，时间结束后，自动醒来
    wait可以有参数也可以没有参数，传入就是在参数时间结束时间后等待，不传入直接等待

  • sleep方法在同步函数或同步代码块中，不释放锁
    wait方法在同步函数或者同步代码块中释放锁

    ReentrantLock实现上述功能

• 可使用if作为判断语句

• newCondition()
  返回Condition用于这种用途实例Lock实例。

    ReentrantLock r=new ReentrantLock();
    Condition c=r.newCondition();

• 使用Lock实例开启锁

    r.lock
    if( flag!=1){
        c.await();
    }

• 使用指定其他锁开启signal

    c.signal();   

• 关闭Lock;
  

•   r.unlock();