滴水穿石-09多线程

1：多线程概述

　　私以为多线程就是一个进程中同时又多个线程执行，就是“多线程”。从代码的角度理解就是一个程序中有多个方法同时运行。（可能不是很准确）

2：多线程实现方案

　　创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。

       创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

2.1 继承Thread 类　　

1：创建MyThread继承Thread类
2：重写run（）方法
3：创建对象
4：启动线程

 

package d9;

public class MyThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread my = new  MyThread();
        MyThread my2 = new  MyThread();
        //my.run();
        //my.run(); 
        //run() 方法仅仅是封装该线程执行的代码，直接调用是管道方法
        //start() 方法首先启动了线程，然后再由jvm去掉用该线程的run方法
        my.start();
        my2.start();
    }
}

2.2 继承Runnable接口

1:自定义一个类MyRunnable实现Runnable接口
2:重写run()方法
3:创建MyRunnable类的对象
4:创建Threadle的对象,并把3创建的对象以参数形式传递

package d9;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}

package d9;

public class MyRunnableDemo {
    public static void main(String[] args) {
         MyRunnable my = new MyRunnable();
         Thread t1 = new Thread(my);
         Thread t2 = new Thread(my,"李四");
         
         t1.setName("张三");
        
         t1.start();
         t2.start();
    }
}

 

2.3 Callable,会在线程池部分讲解

3：设置和获取线程名称

package d9;

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" : "+ i);
        }
    }
}

package d9;

public class MyThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread my = new  MyThread("逍遥");
        MyThread my2 = new  MyThread();
        //my.run();
        //my.run(); 
        //run() 方法仅仅是封装该线程执行的代码，直接调用是管道方法
        //start() 方法首先启动了线程，然后再由jvm去掉用该线程的run方法
    
        my2.setName("小天狼");//给线程命名
        my.start();
        my2.start();
        
        //输出当前线程的方法名臣
        System.out.println(Thread.currentThread().getName());
    }
}

4：线程调度和线程控制

 4.1线程调度

package d9;

public class ThreadPriority extends Thread {
@Override
public void run() {
    // TODO Auto-generated method stub
    for (int i = 0; i <100; i++) {
        System.out.println(getName()+": "+i);
    }
}
}

package d9;

public class ThreadPriorityDemo {

    public static void main(String[] args) {
        //创建线程对象
        MyThread my = new  MyThread("逍遥");
        MyThread my2 = new  MyThread();
         
        my2.setName("小天狼");//给线程命名
        my.start();
        my2.start();
        //线程优先级的范围1-10默认为5
        my2.setPriority(1);
         
    }

}

 4.2线程控制

　　4.2.1 线程休眠

package d9;
import java.util.Date;

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        // TODO Auto-generated method stub
         for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            System.out.println(getName()+":"+i+"当前时间"+new Date());
        }
    }
}

package d9;

public class ThreadSleepDemo {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadSleep s1 = new ThreadSleep();
        ThreadSleep s2 = new ThreadSleep();
        ThreadSleep s3 = new ThreadSleep();
        
        s1.setName("张三");
        s2.setName("李四");
        s3.setName("王五");
        
        s1.start();
        s2.start();
        s3.start();
    }
}

　　4.2.2 线程加入 

package d9;

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" : "+ i);
        }
    }
}

package d9;

public class ThreadJoinDemo {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadJoin s1 = new ThreadJoin();
        ThreadJoin s2 = new ThreadJoin();
        ThreadJoin s3 = new ThreadJoin();
        
        s1.setName("张三");
        s2.setName("李四");
        s3.setName("王五");
        
        s1.start();
        try {
            s1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        s2.start();
        s3.start();
    }
}

　　4.2.3 线程礼让(并不能完全实现)

 package d9;

public class ThreadYield extends Thread {
     
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" : "+ i);
            Thread.yield();
        }
    }
}

package d9;

public class ThreadYieldDemo {
    public static void main(String[] args) {
        //创建线程对象
        ThreadYield my = new  ThreadYield();
        ThreadYield my2 = new  ThreadYield();
         
        my.setName("逍遥");;
        my2.setName("小天狼");//给线程命名
        my.start();
        my2.start();
         
    }
}

　　4.2.4 后台线程(守护线程)

package d9;

public class ThreadDaemon extends Thread {
     
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" : "+ i);             
        }
    }
}

package d9;

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        //创建线程对象
        ThreadDaemon my = new  ThreadDaemon();
        ThreadDaemon my2 = new  ThreadDaemon();
         
        my.setName("逍遥");;
        my2.setName("小天狼"); 
        my.setDaemon(true);
        my2.setDaemon(true);
        my.start();
        my2.start();
        
        Thread.currentThread().setName("杨小可");
        for(int x=0;x<5;x++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

　　4.2.5 中断线程

package d9;

public class ThreadInterruptDemo {
    public static void main(String[] args) {
        //创建线程对象
        ThreadInterrupt my = new  ThreadInterrupt();
          
        my.setName("逍遥");;
     
        my.start();
        //超过3秒如果不醒来,就停止
        try {
            Thread.sleep(3000);
            my.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package d9;

import java.util.Date;

public class ThreadInterrupt extends Thread {
     
    @Override
    public void run() {         
        System.out.println("开始执行: "+new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("线程被终止了 ");
        }
        System.out.println("结束执行: "+new Date());
    }
}

 5 线程的生命周期

　　5.1 简单生命周期

新建:创建线程对象
就绪:有执行资格,没有执行权
运行:有执行资格,有执行权
        阻塞:由于一些操作让线程保护欲了该状态,没有执行资格,没有执行权
                而另一些操作却可以把它激活,激活后处于就绪状态
死亡:线程对象变成垃圾,等待被回收

 5.2 

常见的几种情况

A:新建—就绪—运行—结束
B:新建—就绪—运行—就绪—运行--结束
C:新建—就绪—运行—其他阻塞--就绪—运行—结束
D:新建—就绪—运行—同步阻塞--就绪—运行—结束
E:新建—就绪—运行—等待阻塞--同步阻塞--就绪—运行--结束

6 练习题

　　6.1 模拟电影票售票系统

　　6.1.1 版本1.0

package d9;

public class SellTicket implements Runnable {

    //定义一个资源 100张票
    int ticketNumber = 100;
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (ticketNumber>0) {
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticketNumber+"张票");
                ticketNumber--;
            }else {
                break;
            }
        }
    }

}

package d9;

public class SellTicketDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SellTicket st = new SellTicket();
        
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }

}

　　6.1.2版本2.0 

　　由1.0可以查看出有重复票卖出.这时候应该用static定义一个全局变量

6.1.3 同步代码块

 线程安全分析:由于该线程是多线程的,而且有共享资源(100张票).并且有多条语句操作共享数据(三个窗口).所以会存在安全隐患

同步代码块:
        synchronized(对象){
         需要同步的代码;
    }    

同步方法:即把同步关键字加在方法上,此时的锁对象是this

静态方法的锁对象是累的字节码文件,即SellTicket.class

6.1.4 锁

 6.1.5 死锁:两个锁资源由于相互调用而出现相互等待的现象

package d9;

public class MyLock {
    //第一步,创建两把锁对象
    public static final Object objA = new Object();
    public static final Object objB = new Object();
}

package d9;

public class DieLock extends Thread {
    private boolean flag;
    public  DieLock (boolean flag) {
        this.flag = flag;                
    }
    public void run() {
         if (flag) {
            synchronized (MyLock.objA) {
                System.out.println("if objA");
                synchronized(MyLock.objB) {
                    System.out.println("if objB");
                }
            }
        }else {
            synchronized (MyLock.objB) {
                System.out.println("else objB");
                synchronized(MyLock.objA) {
                    System.out.println("else objA");
                }
            }
        }
    }
}

package d9;

public class DieLockDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DieLock di1 = new DieLock(true);
        DieLock di2 = new DieLock(false);
        
        di1.start();
        di2.start();
    }

}

 7 生产者消费者模式

1:资源类(Student)
2:生产者(SetThread)
3:消费者(GetThread)
4:测试类

7.1 Version1.0

package StudentLX;

public class Student {
    //创建一个资源类,Student
    String name;
    int age;
}

package StudentLX;

public class SetThread implements Runnable {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub 
        s.name = "逍遥";
        s.age = 18;
    }

}

package StudentLX;

public class GetThread implements Runnable {
    private Student s ;
     public GetThread (Student s) {
         this.s =s;                 
     }
    public void run() {
         
        System.out.println("姓名:"+s.name+"年龄: "+s.age);
    }
}

package StudentLX;

public class StudentDemo {

    public static void main(String[] args) {
        //创建资源
        Student s = new Student();
        //设置和获取类
        GetThread gt= new GetThread(s);
        SetThread st= new SetThread(s);    
        //创建线程
        Thread t1 = new Thread(gt); 
        Thread t2 = new Thread(st);
        //启动线程
        t1.start();
        t2.start();
        
    }

}

多线程问题是会存在安全隐患的.进一步修改SetThread和GetThread方法

7.2 Version2.0

package StudentLX;

public class SetThread implements Runnable {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub 
        int i =1;
        while (true) {
            if (i%2==0) {
                s.name = "逍遥";
                s.age = 18;
            }else {
                s.name = "小天狼";
                s.age = 22;
            }
            i++;
        }
        
    }

}

package StudentLX;

public class GetThread implements Runnable {
    private Student s ;
     public GetThread (Student s) {
         this.s =s;                 
     }
    public void run() {
         
         while (true) {
             System.out.println("姓名: "+s.name+";---: "+s.age);
             
        }
        
    }
}

原因分析以及解决方法

A:多线程环境;B:共享同一资源;C共用同一代码.

解决方法线程同步:A:不同种类的线程都要加锁(GetThread和SetThread);B不同种类的线程加同一把锁

package StudentLX;

public class SetThread implements Runnable {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i = 1;
        while (true) {
            synchronized (s) {
                if (i % 2 == 0) {
                    s.name = "逍遥";
                    s.age = 18;
                } else {
                    s.name = "小天狼";
                    s.age = 22;
                }
                i++;
            }
        }

    }

}

package StudentLX;

public class GetThread implements Runnable {
    private Student s ;
     public GetThread (Student s) {
         this.s =s;                 
     }
    public void run() {
         
         while (true) {
             synchronized (s) {
                 System.out.println("姓名: "+s.name+";---: "+s.age);                 
            }             
        }        
    }
}

  

7.3 Version3.0 等待唤醒机制

思路:

　　A:生产者　　先看是否有数据,有就等待;没有就生产,生产完之后通知消费者进行消费

　　B:消费者　　先看是否有数据,有就消费;没有就等待,通知生产者生产数据

等待唤醒

Object类中提供了三个方法

　　wait():等待

　　notify():唤醒单个线程

　　notifyAll():唤醒所有线程

package StudentLX;

public class Student {
    //创建一个资源类,Student
    boolean flag;//定义一个标志,用于判断是否有数据
    String name;
    int age;
}

package StudentLX;

public class SetThread implements Runnable {
    private Student s;
    
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i = 1;
        while (true) {
            synchronized (s) {
                //生产者:如果有就等待 ;如果没有就生产;
                if (s.flag) {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (i % 2 == 0) {
                    s.name = "逍遥";
                    s.age = 18;
                } else {
                    s.name = "小天狼";
                    s.age = 22;
                }
                i++;
                s.flag=true;
                //生产完成,通知消费者(唤醒线程)
                s.notify();
            }
        }

    }

}

package StudentLX;

public class GetThread implements Runnable {
    private Student s ;
     public GetThread (Student s) {
         this.s =s;                 
     }
    public void run() {
         
         while (true) {
             synchronized (s) {
                 //消费者,如果有就消费;没有就等待
                 if (!s.flag) {
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                 System.out.println("姓名: "+s.name+";---: "+s.age);        
                 //修改标记
                 s.flag=false;
                 s.notify();
            }             
        }        
    }
}

package StudentLX;

public class StudentDemo {

    public static void main(String[] args) {
        //创建资源
        Student s = new Student();
        //设置和获取类
        GetThread gt= new GetThread(s);
        SetThread st= new SetThread(s);    
        //创建线程
        Thread t1 = new Thread(gt); 
        Thread t2 = new Thread(st);
        //启动线程
        t1.start();
        t2.start();
        
    }

}

 7.4  version4.0 　　Student变量私有化

package StudentLX;

public class Student {
    // 第一步,修改为私有成员
    private boolean flag;//  
    private String name;
    private int age;

    //第二步,创建SetStudent方法,并设置为同步方法
    public synchronized void  setStudent(String name,int age) {
        //如果存在,等待
         if (this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
         //创建
        this.name = name;
        this.age = age;
        //修改标签
        this.flag=true;
        //唤醒
        this.notify();
    }

    public synchronized void getStudent() {
        //如果不存在,等待
         if (!this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
         //使用
         System.out.println(this.name+"---"+this.age);
        //修改标签
        this.flag=false;
        //唤醒
        this.notify();
        
    }


     
     
}

package StudentLX;

public class SetThread implements Runnable {
    private Student s;
    
    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i = 1;
        while (true) {
             
                if (i % 2 == 0) {
                    s.setStudent("逍遥", 18);
                } else {
                    s.setStudent("小天狼", 22);
                }
                i++;
                 
            }
        } 

}

package StudentLX;

public class GetThread implements Runnable {
    private Student s ;
     public GetThread (Student s) {
         this.s =s;                 
     }
    public void run() {
         
         while (true) {
              s.getStudent();     
        }        
    }
}

package StudentLX;

public class StudentDemo {

    public static void main(String[] args) {
        //创建资源
        Student s = new Student();
        //设置和获取类
        GetThread gt= new GetThread(s);
        SetThread st= new SetThread(s);    
        //创建线程
        Thread t1 = new Thread(gt); 
        Thread t2 = new Thread(st);
        //启动线程
        t1.start();
        t2.start();
        
    }

}

8 线程组:多个线程组合到一起

package d9;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}

package d9;

public class ThreadGroupDemo {

    public static void main(String[] args) {
        // 获取线程所属线程组的名称
        method1();
        // 设置线程所属的线程组
        method2();
    }

    private static void method2() {
        // 创建一个线程组
        ThreadGroup tg = new ThreadGroup("新的线程组");
        MyRunnable my = new MyRunnable();
        // 创建线程对象,并分组
        Thread t1 = new Thread(tg, my, "逍遥new");         
        Thread t2 = new Thread(tg, my, "小天狼new");
         
        // 输出线程名称
        System.out.println(t1.getThreadGroup().getName()  );
        System.out.println(t2.getThreadGroup().getName()  );
        // 通过线程组控制该组内的所有线程,例如:设置优先级和后台线程
        tg.setMaxPriority(4);
    }

    private static void method1() {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my, "逍遥");
        Thread t2 = new Thread(my, "小天狼");

        // 获取线程的所属线程组
        ThreadGroup gt1 = t1.getThreadGroup();
        ThreadGroup gt2 = t2.getThreadGroup();

        // 通过ThreadGroup中的getName()方法获取线程组名称
        String name1 = gt1.getName();
        String name2 = gt2.getName();

        System.out.println(name1);
        System.out.println(name2);

        // 获取main线程的线程组名称
        System.out.println(Thread.currentThread().getThreadGroup().getName());
    }

}

 9 线程池

9.1 通过实现Runnable接口

A:创建一个线程池对象,控制要创建几个线程对象
    public static ExecutorService newFixedThreadPoll(int nThreads) 
B:这种线程池的线程可以执行
    可以执行Runnable对象或者Callable对象代表的线程
    做一个类实现Runnable接口
C:调用如下方法
    Future<?> submit(Runnable task)
    <T> Future<T> subbmit(Callable<T> task)

package d9;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}

package d9;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ExecutorsDemo {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService tpool = Executors.newFixedThreadPool(2);
        //创建线程对象,并放入到线程池中
        tpool.submit(new MyRunnable());
        tpool.submit(new MyRunnable());
        //结束线程池
        tpool.shutdown();
    }
}

 9.2 通过实现Callable接口

package d9;

import java.util.concurrent.Callable;

public class MyCallable implements Callable {

    @Override
    public Object call() throws Exception {
         for (int i = 0; i < 100; i++) {
             System.out.println(Thread.currentThread().getName()+":"+i);
        }
         
        return null;
    }

}

package d9;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CallableDemo {

    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
        pool.submit(new MyCallable());
        pool.submit(new MyCallable());
    }
    }

 9.3 通过实现Callable接口实现具有返回值的线程池(求和)

package d9;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {

    private int startNumber;
    private int endNumber;
    public MyCallable(int startNumber,int endNumber) {
        this.startNumber = startNumber;
        this.endNumber = endNumber;
    }
    @Override
    public Integer call() throws Exception {
         int sum=0;
         for (int i = startNumber; i <= endNumber; i++) {
             sum+=i;
        }
         
        return sum;
    }

}

package d9;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableDemo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        
    Future<Integer> sum1=    pool.submit(new MyCallable(1,100));
    Future<Integer> sum2=    pool.submit(new MyCallable(1,50));
    
    int f1 = sum1.get();
    
    System.out.println(f1);
    System.out.println(sum2.get());
    }
    }

 10 匿名内部类实现多线程

package d9;

public class ThreadAnonymous {

    public static void main(String[] args) {
        // 01 继承Thread类 实现多继承
        new Thread() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Hello" + i);
                }
            };
        }.start();
        // 02 通过实现runable接口来实现
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("World" + i);
                }
            }
        }) {
        }.start();
        // 03 混合实现,其实只走方法内部的
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("java" + i);
                }
            }
        }) {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("!!" + i);
                }
            };
        }.start();
    }

}

 11 定时线程

 　　定时器:可以在指定的时间做某件事情,还可以重复做某件事情

　　依赖Timer(定时)和TimerTask(任务)这两个类

import java.util.Timer;
import java.util.TimerTask;

public class TimeDemo {
    public static void main(String[] args) {
        //创建定时器对象
        Timer t = new Timer();
        //执行任务
        t.schedule(new MyTask(), 3000);
    }
}

class MyTask extends TimerTask{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("beng,爆炸了!!!");
    }
}

import java.util.Timer;
import java.util.TimerTask;

public class TimeDemo {
    public static void main(String[] args) {
        //创建定时器对象
        Timer t = new Timer();
        //执行任务+结束任务
        t.schedule(new MyTask(t), 3000);
    }
}

class MyTask extends TimerTask{
    private Timer t;
    public MyTask() {}
    public MyTask(Timer t) {
        this.t =t;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("beng,爆炸了!!!");
        t.cancel();
    }
}

 
import java.util.Timer;
import java.util.TimerTask;

public class TimeDemo {
    public static void main(String[] args) {
        //创建定时器对象
        Timer t = new Timer();
        //执行任务+结束任务
        //3秒后执行爆炸任务,如果不成功,每个2秒后再继续炸
        t.schedule(new MyTask(), 3000,2000);
    }
}

class MyTask extends TimerTask{
     
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("beng,爆炸了!!!");
         
    }
}

 练习:定时删除指定文件夹

package d9;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.Timer;
import java.util.TimerTask;

public class FolderDelete {
    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        Timer t = new Timer();
        //执行任务 
        String stTime = "2018-3-30 07:21:06";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(stTime);
        t.schedule(new DeleteFolder(), d,100000);
    }
}

class DeleteFolder extends TimerTask{
     
    @Override
    public void run() {
         File srcFolder = new File("D:\aaa");
         deleteFolder(srcFolder);
        System.out.println("beng,爆炸了!!!");
         
    }

    private void deleteFolder(File srcFolder) {
        // TODO Auto-generated method stub
        File [] fileArray = srcFolder.listFiles();
        if (fileArray != null) {
            for (File file : fileArray) {
                if (file.isDirectory()) {
                    deleteFolder(file);
                }else {
                    file.delete();
                }
            }
            srcFolder.delete();
        }
    }
}