看了张老师的关于定时器的应用，产生了一个疑问。

1. 
   
2. public class My extends Thread {
   
3.         public static void main(String args[]) throws Exception
   
4.         {
   
5.                
   
6.                 Thread t1=new My();
   
7.                 t1.start();
   
8.         }
   
9.         public void run()
   
10.         {
    
11.                 while(true)
    
12.                 {
    
13.                         try {
    
14.                                 Thread.sleep(1000);
    
15.                         } catch (InterruptedException e) {
    
16.                                 e.printStackTrace();
    
17.                         }
    
18.                         System.out.println("hello");
    
19.                 }
    
20.         }
    
21. }
    

复制代码

这个是每隔一秒输出一句hello。

1. import java.util.concurrent.Executors;
   
2. import java.util.concurrent.ScheduledExecutorService;
   
3. import java.util.concurrent.TimeUnit;
   
4. 
   
5. 
   
6. public class My2  {
   
7.         public static void main(String args[]) throws Exception
   
8.         {
   
9.                 ScheduledExecutorService se=Executors.newScheduledThreadPool(1);
   
10.                 se.scheduleAtFixedRate(
    
11.                                 new Runnable(){
    
12.                                         public void run() {
    
13.                                                 System.out.println("hello");
    
14.                                         }},
    
15.                                 1,
    
16.                                 1,
    
17.                                 TimeUnit.SECONDS);
    
18.         }
    
19. }
    

复制代码

这个也是每隔一秒输出一句hello。
都是线程，完成同样的功能，有什么区别呢？

第一个只是定义了一个线程，如果起两个或者两个以上的线程，那么它们会并发执行。
第二个定义的是线程池，它可以控制并发执行的线程数，如果达到最大值，那么之后的线程就要处于等待状态，等之前的线程执行完成之后释放池空间，才可进入执行。
ScheduledExecutorService se=Executors.newScheduledThreadPool(1);
你定义的线程池容量为1，也就是说，如果有两个线程同时执行，它们不会并发执行，只能第一个先进去，等执行完毕，释放线程池空间才能让第二个进入。

创建线程的两种方式：
（1）， 继承Thread类
1.子类覆盖父类中的run方法，将线程运行的代码存放在run中。
2.建立子类对象的同时线程也被创建。
3.通过调用start（）方法开启线程。
（2），实现Runnable接口
1.子类覆盖接口中的run方法。
2.通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。
3.Thread类对象调用start方法开启线程
在功能实现上没什么区别，只是因为java是单继承的，所以不可能让所有的类都继承Thread类，所以必须有这个Runnable 接口。
一般来说编程都会去 实现Runnble 接口，而不会采用继承Thread。

楼上，感谢你回答我的问题，可是你所答非所问啊。