java多线程实现定时器任务

volatile是一个弱同步机制关键字，只能实现同步机制中的可见功能，不能实现互斥访问。用在变量的声明上时，表示多个线程获取此变量时，都是最新的数据（变量会自动更新最新数据）。
synchronized 是一个内置锁，也就是java内部加锁机制。用在方法上时，每个线程进入的时候，它会获得方法所在的对象的锁，离开方法后释放对象锁。 
自定义定时任务
   任务管理类

package com.effectJava.Chapter3;

import java.util.concurrent.TimeUnit;

public class ManagerTask {

    private  static  boolean isManagerTaskEnd;

    public synchronized  static void setIsManagerTaskEnd(boolean flage) {
       isManagerTaskEnd = flage;
    }

    public synchronized static boolean isIsManagerTaskEnd() {
        return isManagerTaskEnd;
    }

//    private static mytimeTask timetask = new mytimeTask();

    public static void main(String... args) throws Exception {
//        开启任务线程
        new Thread(){
            @Override
            public void run() {
                while (true){
                    if(isIsManagerTaskEnd()){//没开启任务线程
                        setIsManagerTaskEnd(false);
                        new mytimeTask().start();
                    }
                }

            }
        }.start();
        //开启timetask任务
        setIsManagerTaskEnd(true);


        TimeUnit.SECONDS.sleep(1);

        //关闭
//        setIsManagerTaskEnd(false);
        //关闭timetask
        mytimeTask.setFlagesTrue(true);

        TimeUnit.SECONDS.sleep(2);

        mytimeTask.setFlagesTrue(false);
        setIsManagerTaskEnd(true);

    }


}

任务处理类

package com.effectJava.Chapter3;

public class mytimeTask  extends   Thread{

    private  volatile  static boolean flages ;

    private  static  int count;
    //设置可见性
    public static   boolean isFlages() {
        return flages;
    }

    public  static   void setFlagesTrue(boolean flage) {
        flages = flage;
    }

    @Override
    public void run() {
        while (!isFlages()) {
            System.out.println("执行任务");
            //执行任务代码
        }
    }


    public  synchronized static  int reCount() {
        return count++;
    }

    public  synchronized static  int getCount() {
        return count;
    }
}