不可能完成任务？Thread的超时自动终止

package thread;

public class ThreadTimeout extends Thread {

	public long startTimeMillis = 0;

	public volatile boolean finished = false;

	Thread thread;

	public ThreadTimeout() {

		this.startTimeMillis = System.currentTimeMillis();
		System.out.println("startTimeMillis" + startTimeMillis);
		start();
	}

	public static void main(String args[]) {
		ThreadTimeout a = new ThreadTimeout();
		a.doWork();
	}

	public void run() {
		while (!finished) {
			timeout();
		}
	}

	private void doWork() {
		int i = 0;
		while(true){
			if (finished) {
				System.out.println("time out");
				break;
			}
			System.out.println(i++);
		}
	}

	private boolean timeout() {
		long accessTime = System.currentTimeMillis() - startTimeMillis;
		while (accessTime < 600) {
			System.out.println("accessTime   " + accessTime);
			return true;
		}
		finished = true;

		return false;
	}
}

package thread;

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

public class ThreadA extends Thread {

	private static final int MAX_TIME = 80;
	private boolean running = true;

	public ThreadA(String name) {
		super(name);			
		Timer timer = new Timer();	
		EndThreadTask task = new EndThreadTask(this);
		timer.schedule(task, MAX_TIME);
	}
	
	public void run() {
		try {
			this.sleep(1000);
			//业务逻辑
		} catch (InterruptedException e) {
			System.out.println("错误终止");
		}	
	}
	
	public void doWorks(){
		long startTime = System.currentTimeMillis();

			Random rand = new Random(System.nanoTime());
			int delay = rand.nextInt(100);
			while(true){
				System.out.println("我还在运行呢");
			}
		}
	
	public void stopRunning(){
		this.running = false;
	}
	
	public static void main(String args[]){		
		ThreadA a = new ThreadA("a");
		a.start();
	}

}

class EndThreadTask extends TimerTask{
	private ThreadA thread;
	
	public EndThreadTask(ThreadA thread){
		this.thread = thread;
	}
	
	public void run() {		
		System.out.println(this.thread.getName()+"超时");
		this.thread.interrupt();
	}
	
}

ScheduledExecutorService scheduledExecutorService=Executors.newScheduledThreadPool(5);
ScheduledFuture<?> future =scheduledExecutorService.scheduleAtFixedRate(new Runnable(){
			@Override
			public void run() {
				//do something
			}
		}, 1,8, TimeUnit.MINUTES)
;
future.cancel()

 import static java.util.concurrent.TimeUnit.*;
 class BeeperControl {
    private final ScheduledExecutorService scheduler = 
       Executors.newScheduledThreadPool(1);

    public void beepForAnHour() {
        final Runnable beeper = new Runnable() {
                public void run() { System.out.println("beep"); }
            };
        final ScheduledFuture<?> beeperHandle = 
            scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
        scheduler.schedule(new Runnable() {
                public void run() { beeperHandle.cancel(true); }
            }, 60 * 60, SECONDS);
    }
 }

 import static java.util.concurrent.TimeUnit.*;
 class BeeperControl {
    private final ScheduledExecutorService scheduler = 
       Executors.newScheduledThreadPool(1);

    public void beepForAnHour() {
        final Runnable beeper = new Runnable() {
                public void run() { System.out.println("beep"); }
            };
        final ScheduledFuture<?> beeperHandle = 
            scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
        scheduler.schedule(new Runnable() {
                public void run() { beeperHandle.cancel(true); }
            }, 60 * 60, SECONDS);
    }
 }

import java.util.concurrent.*;
public class BeeperControl {   
   private final ScheduledExecutorService scheduler =    
      Executors.newScheduledThreadPool(1);   
  
   public void beepForAnHour() {   
       final Runnable beeper = new Runnable() {   
               public void run() {
            	   //业务
            	   while(true) 
            		   System.out.println("do my task");
            	   }   
           };   
       final ScheduledFuture<?> beeperHandle =    
           scheduler.scheduleAtFixedRate(beeper, 10, 10, TimeUnit.MILLISECONDS);   
       scheduler.schedule(new Runnable() {   
               public void run() { 
            	   beeperHandle.cancel(true);
            	   System.out.println("task canceled");
            	  }   
           }, 60 * 60, TimeUnit.MILLISECONDS);   
   }   
   
   public static void main(String args[]){
	   BeeperControl b = new BeeperControl();
	   b.beepForAnHour();
   }
} 

/**
     * Executes <code>task</code>. Waits for <code>timeout</code>
     * milliseconds for the task to end and returns. If the task does not return
     * in time, the thread is interrupted and an Exception is thrown.
     * The caller should override the Thread.interrupt() method to something that
     * quickly makes the thread die or use Thread.isInterrupted().
     * @param task The thread to execute
     * @param timeout The timeout in milliseconds. 0 means to wait forever.
     * @throws TimeoutException if the timeout passes and the thread does not return.
     */
    public static void execute(Thread task, long timeout) throws TimeoutException {
        task.start();
        try {
            task.join(timeout);
        } catch (InterruptedException e) {
            /* if somebody interrupts us he knows what he is doing */
        }
        if (task.isAlive()) {
            task.interrupt();
            throw new TimeoutException();
        }
    }

/**
     * Executes <code>task</code>. Waits for <code>timeout</code>
     * milliseconds for the task to end and returns. If the task does not return
     * in time, the thread is interrupted and an Exception is thrown.
     * The caller should override the Thread.interrupt() method to something that
     * quickly makes the thread die or use Thread.isInterrupted().
     * @param task The thread to execute
     * @param timeout The timeout in milliseconds. 0 means to wait forever.
     * @throws TimeoutException if the timeout passes and the thread does not return.
     */
    public static void execute(Thread task, long timeout) throws TimeoutException {
        task.start();
        try {
            task.join(timeout);
        } catch (InterruptedException e) {
            /* if somebody interrupts us he knows what he is doing */
        }
        if (task.isAlive()) {
            task.interrupt();
            throw new TimeoutException();
        }
    }

public class ThreadA extends Thread {
	
	private long startTime;

	public ThreadA(String name) {
		super(name);
	}

	public void run() {
		this.startTime = System.currentTimeMillis();
		int i = 0;
		while (i++<20) {
			try {
				this.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(this.getName()+":"+i);
		}

		System.out.println(this.getName()+"已完成");

	}
}