Java多线程——线程池与定时器

线程组：

          1.Java中使用ThreadGroup来表示线程组。

          2.作用：对一批线程进行分类管理。

                      Java程序允许程序直接对线程组控制。

         3.默认情况下，所有线程都属于主线程组。

                   public final ThreadGroup getThreadGroup();  //返回该线程所属的线程组

         4.线程组里的方法：public final String getName();          

Thread.currentThread().getThreadGroup.getName(); //先获取当前的线程，再获取所在线程组，再获取线程组名称

          5.线程类里的方法

               a. 构造方法ThreadGroup(String name);  // 创建一个线程组

                 b.构造方法Thread(ThreadGroup group,Runnable target,String name); //分配新的线程组，线程(运行)对象，线程名

            线程组里的方法可以实现对整组里的线程操作，如全部设置成后台线程等等。

线程池的使用:

          1.线程池中的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下个对象来使用。

          2.特点：提高程序的运行效率

          3.jdk5之后Java内置线程池。

          4.Executors工厂类产生线程池

                     a.public static ExecutorService newCachedThreadPool(); 新创建线程池

                     b.public static ExecutorService newFixedThreadPool(int nThread); 创建n个线程

                     c.public static ExecutorService newSingleThreadExecutor();创建一个线程

                    d.public void shutdown();结束线程

                 方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象的线程

          5.     Future<T> submit(Callablel<T> task);  Callable 调用

                 Future<?> submit(Runnable task);       Runnable调用

多线程实现方式3—实现Callable接口

         方法：public object call();      泛型Callable<Object>

         和Runnable用法相似，不同点就是有泛型，并且只能依赖于线程池使用。可以抛出异常。

匿名内部类方式使用多线程

         匿名内部类的格式：

                    new  类名或者接口名() {

                                重写方法;

                    };

                     本质：是该类或者接口的子类对象

         两种方式实现多线程：

                     1.继承Thread类来实现多线程

            

  
  

   
   

    
        new Thread() {
   
   
   
   

    
             public void run() {
   
   
   
   

    
                 for(int x=0;x<100;x++) {
   
   
   
   

    
                      System.out.println(Thread.currentThread().getName()+":"+x);
   
   
   
   

    
                 }
   
   
   
   

    
             }
   
   
   
   

    
         }.start();
   
   
  
  

                        2.实现Runnable接口来实现多线程

 

  
  

   
   

    
           new Thread(new Runnable() {
   
   
   
   

    
                public void run() {
   
   
   
   

    
                    for(int x=0;x<100;x++) {
   
   
   
   

    
                         System.out.println(Thread.currentThread().getName()+":"+x);
   
   
   
   

    
                    }
   
   
   
   

    
                }
   
   
   
   

    
           }){}.start();
   
   
  
  

定时器的概述和使用：

           调度多个定时任务，以后台线程的方式执行。（线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。）

          通过Timer（定时器类）和TimerTask（任务类）来实现定义调度的功能。

         自定义类继承任务类，测试类中创建定时器对象。void schedule(TimerTask task,long delay，long period); 调用方法（任务对象，多长时间（或者定义一个时间）执行第一次，再次执行多长时间后）

           void cancel(); 终止计时器 自定义类中的run()方法调用

   
   

    
    

     
     public class TaskDemo {
    
    
    
    

     
             public static void main(String[] args) {
    
    
    
    

     
                     Timer t = new Timer();
    
    
    
    

     
                     t.schedule(new MyTask(),3000);
    
    
    
    

     
                         
    
    
    
    

     
                     //结束任务
    
    
    
    

     
                     //t.schedule(new MyTask(t),3000);
    
    
    
    

     
              }
    
    
    
    

     
     }
    
    
    
    

     
     class MyTask extends TimerTask {
    
    
    
    

     
             private Timer t;
    
    
    
    

     
             public MyTask() {}
    
    
    
    

     
             public MyTask(Timer t) {
    
    
    
    

     
                     this.t = t;
    
    
    
    

     
             }
    
    
    
    

     
             
    
    
    
    

     
             public void run() {
    
    
    
    

     
                     System.out.println("beng 爆炸了");
    
    
    
    

     
                     t.cancel();
    
    
    
    

     
             }
    
    
    
    

     
     }
    
    
   
   

       定时删除指定的文件夹目录例子：

   
   

    
    

     
     class DeleteFile extends TimerTask {
    
    
    
    

     
     

    
    
    
    

     
          public void deleteFolder(File f) {
    
    
    
    

     
              File[] file = f.listFiles();
    
    
    
    

     
              if( file!=null ) {
    
    
    
    

     
                  for(File s : file) {
    
    
    
    

     
                      if(s.isDirectory()) {
    
    
    
    

     
                          deleteFolder(s);       //递归
    
    
    
    

     
                      } else {
    
    
    
    

     
                          s.delete();
    
    
    
    

     
                      }
    
    
    
    

     
                  }
    
    
    
    

     
                  f.delete();
    
    
    
    

     
             }
    
    
    
    

     
          }
    
    
    
    

     
          public void run() {
    
    
    
    

     
              File f = new File("文件名");
    
    
    
    

     
              deleteFolder(f);
    
    
    
    

     
          }
    
    
    
    

     
     }
    
    
    
    

     
      
    
    
    
    

     
     public class TimerTest {
    
    
    
    

     
          public static void main(String[] args) {
    
    
    
    

     
             Timer t = new Timer();
    
    
    
    

     
     

    
    
    
    

     
             String s = "2016-6-20 9:48:50";
    
    
    
    

     
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
    
    
    
    

     
             Date d = sdf.parse(s);            
    
    
    
    

     
      
    
    
    
    

     
             t.schedule(new DeleteFile(),d);
    
    
    
    

     
          }
    
    
    
    

     
     }