java线程真的太难了！！！

public class PrintThread extends Thread {  
   
    public void run() {  
        System.out.println("我是线程！ 继承自Thread");  
    }  
    public static void main(String args[]) {  
        (new PrintThread()).start();  
    }  
} 

public class HelloRunnable implements Runnable {  
      
    public void run() {  
        System.out.println("我也是一个线程，实现了接口");  
    }  
  
    public static void main(String args[]) {  
        (new Thread(new HelloRunnable())).start();  
    }  
  
}  

/**
*
* @author dgm
* @describe "测试打印定时器"
* @date 2017年4月10日
*/

  //注：public abstract class TimerTask implements Runnable

public class PrintTimerTask extends TimerTask {

    private String name;
    public PrintTimerTask(String name) {
        super();
        this.name = name;
    }
    @Override
    public void run() {
        if (System.currentTimeMillis( ) - scheduledExecutionTime( ) > 5000) {
            // 让下一个任务执行
            return;
        }
        System.out.println("周期性任务（好比每天早晨定闹钟）线程："+ name +"***** 在 执行。。"); 
    }
}

public class TimeTaskTest {

    public static void main(String[] args) {
        Timer timer = new Timer();
        //设置3秒后启动任务
        timer.schedule(new PrintTimerTask("name-0"), 3000);
        PrintTimerTask secondTask = new PrintTimerTask("name-1");
        // 1秒后启动任务,以后每隔3秒执行一次线程
        timer.schedule(secondTask, 1000, 3000);
        Date date = new Date();
        // 以date为参数，指定某个时间点执行线程
        timer.schedule(new PrintTimerTask("name-3"), new Date(
                date.getTime() + 5000));
    }
}

/**
 * 
 * @author dgm
 * @describe ""
 * @date 2020年4月10日
 */
public class PrintScheduledExecutor implements Runnable {

    private String jobName;

    public PrintScheduledExecutor() {

    }

    public PrintScheduledExecutor(String jobName) {
        this.jobName = jobName;
    }

    @Override
    public void run() {

        System.out.println("调度： "+ jobName + " 正在运行中！！！");
    }
}

/**
 * @author dgm
 * @describe ""
 * @date 2020年4月10日
 */
public class ScheduledThreadPoolTest {
    
    public static void main(String[] args) {
     
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

        long initialDelay = 1;
        long period = 1;
        // ，固定频率，到期执行，从现在开始1秒钟之后，每隔1秒钟执行一次job1
        service.scheduleAtFixedRate(new PrintScheduledExecutor("job1"),
                initialDelay, period, TimeUnit.SECONDS);

        // 频率不一定固定，从现在开始2秒钟之后，每隔2秒钟执行一次job2
        service.scheduleWithFixedDelay(new PrintScheduledExecutor("job2"),
                initialDelay, period, TimeUnit.SECONDS);
    }    
}

 /**
     * Creates a thread pool that can schedule commands to run after a
     * given delay, or to execute periodically.
     * @param corePoolSize the number of threads to keep in the pool,
     * even if they are idle
     * @return a newly created scheduled thread pool
     * @throws IllegalArgumentException if {@code corePoolSize */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

 /**
     * Creates a new {@code ScheduledThreadPoolExecutor} with the
     * given core pool size.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @throws IllegalArgumentException if {@code corePoolSize */
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

 
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize 
            maximumPoolSize 
            maximumPoolSize 
            keepAliveTime )
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

最后一种方式参数清晰明了