Java中停止线程执行的方法
 
作者：chszs，转载需注明。博客主页：http://blog.csdn.net/chszs
 
一、暂停或停止线程的理论
 
在Java编程中，要暂停或停止当前正在运行的线程，有几种方法。对于把线程转入睡眠Sleep状态，使用Thread.sleep()是最正确的方式。或许有人会问，为什么不使用等待wait()或通知notify()？要知道，使用等待或通知都不是很好的方式。
 线程可以使用等待wait()实现被阻塞，这属于条件等待的方式，当条件满足后，又会从阻塞转为等待状态。尽管可以在等待wait()条件那里放一个超时设置，但等待wait()的设计目的不是这样的，等待wait()在设计上是用于Java线程间的通信。
 
 
而使用睡眠sleep()方式，可以让线程从当前开始睡眠指定的时间。注意不要使用睡眠sleep()方式去代替等待wait()或通知notify()，反之亦然。
 等待wait()或通知notify()不应该用于暂停线程，还有一个原因，等待wait()或通知notify()需要一个锁。只能从一个同步的方法或同步的代码块去调用它们，获取锁和释放锁的开销是比较大的。而且，只是暂停线程的话，无需引入锁机制。
 sleep()与wait()还有一点不同，sleep()会把当前的线程转入等待状态，它不会释放它持有的任何锁，而wait()使得线程转入阻塞状态，会释放掉自己持有的锁。
 总之，Java多线程编程并不简单，即使是简单的任务，如创建线程、停止线程或暂停线程，都需要认真掌握Java API。
 
二、暂停或停止线程的实战
 
下面的例子中，要暂停线程，可以使用Thread.sleep()或TimeUnit.sleep()方法。例子中，有两个线程，主线程由JVM启动，它执行main()方法。第二个线程叫T1，它由主线程创建，用于循环运行游戏。我们传递的Runnable任务是一个无限循环，会一直运行直到我们停止它。注意看，我使用了volatile关键字。
 主线程首先启动T1线程，再使用stop()方法停止线程。
 在这个例子中，我们有两种方法停止线程的运行，使用Thread.sleep()方法或者是使用TimeUnit.sleep()方法。TimeUnit类既可以指定秒即TimeUnit.SECONDS，又可以指定毫秒即TimeUnit.MILLISECONDS。总的来说，使用TimeUnit的sleep()方法，使得代码更为易读。
 
import static java.lang.Thread.currentThread;
import java.util.concurrent.TimeUnit;
public class ThreadPauseDemo{
    public static void main(String args[]) throws InterruptedException {
        Game game = new Game();
        Thread t1 = new Thread(game, "T1");
        t1.start();
        // 现在停止Game线程
        System.out.println(currentThread().getName() + " is stopping game thread");
        game.stop();
        // 查看Game线程停止的状态
        TimeUnit.MILLISECONDS.sleep(200);
        System.out.println(currentThread().getName() + " is finished now");
    }
}

class Game implements Runnable{
    private volatile boolean isStopped = false;
    public void run(){
        while(!isStopped){
            System.out.println("Game thread is running......");
            System.out.println("Game thread is now going to pause");
            try{
                Thread.sleep(200);
            } catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("Game thread is now resumed......");
        }
        System.out.println("Game thread is stopped......");
    }
    public void stop(){
        isStopped = true;
    }
}
 
程序输出如下：
 
Game thread is running......
main is stopping game thread
Game thread is now going to pause
Game thread is now resumed......
Game thread is stopped......
main is finished now
 
注： 
 volatile关键字：当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取这个值时，它会去主内存中读取新值。volatile关键字保证了可见性。普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
 通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
 一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么它就具备了两层语义：
 
保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
禁止进行指令重排序。
 
volatile关键字禁止指令重排序有两层意思：
 
当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行。
在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
 volatile一般情况下不能代替sychronized，因为volatile不能保证操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。
 
三、sleep()方法总结
 
Thread.sleep()方法可以让线程暂停或停止，它还有一些细节需要注意：
 
Thread.sleep()方法是一个静态方法，它总是可以让当前的线程转入睡眠。
可以调用interrupt()方法把当前睡眠的线程唤醒。
sleep()方法不能保证线程能精准地在指定那一毫秒内转入睡眠，它的精度取决于系统的计时器。
它不会释放它所获得的锁。

 
 
如何停止java的线程一直是开发多线程程序的一个非常头痛的问题，本文我们就来讨论一下关于Java中停止线程执行的方法，我们应该如何正确停止java中的线程。
 
 
 
 
 Java中停止线程执行的方法
 
 一、暂停或停止线程的理论
 
 在Java编程中，要暂停或停止当前正在运行的线程，有几种方法。对于把线程转入睡眠Sleep状态，使用Thread.sleep()是最正确的方式。或许有人会问，为什么不使用等待wait()或通知notify()？要知道，使用等待或通知都不是很好的方式。
 线程可以使用等待wait()实现被阻塞，这属于条件等待的方式，当条件满足后，又会从阻塞转为等待状态。尽管可以在等待wait()条件那里放一个超时设置，但等待wait()的设计目的不是这样的，等待wait()在设计上是用于Java线程间的通信。
 而使用睡眠sleep()方式，可以让线程从当前开始睡眠指定的时间。注意不要使用睡眠sleep()方式去代替等待wait()或通知notify()，反之亦然。
 Java线程通信的例子： http://javarevisited.blogspot.sg/2013/12/inter-thread-communication-in-java-wait-notify-example.html
 等待wait()或通知notify()不应该用于暂停线程，还有一个原因，等待wait()或通知notify()需要一个锁。只能从一个同步的方法或同步的代码块去调用它们，获取锁和释放锁的开销是比较大的。而且，只是暂停线程的话，无需引入锁机制。
 sleep()与wait()还有一点不同，sleep()会把当前的线程转入等待状态，它不会释放它持有的任何锁，而wait()使得线程转入阻塞状态，会释放掉自己持有的锁。
 总之，Java多线程编程并不简单，即使是简单的任务，如创建线程、停止线程或暂停线程，都需要认真掌握Java API。
 
 二、暂停或停止线程的实战
 
 下面的例子中，要暂停线程，可以使用Thread.sleep()或TimeUnit.sleep()方法。例子中，有两个线程，主线程由JVM启动，它执行main()方法。第二个线程叫T1，它由主线程创建，用于循环运行游戏。我们传递的Runnable任务是一个无限循环，会一直运行直到我们停止它。注意看，我使用了volatile关键字。
 主线程首先启动T1线程，再使用stop()方法停止线程。
 在这个例子中，我们有两种方法停止线程的运行，使用Thread.sleep()方法或者是使用TimeUnit.sleep()方法。TimeUnit类既可以指定秒即TimeUnit.SECONDS，又可以指定毫秒即TimeUnit.MILLISECONDS。总的来说，使用TimeUnit的sleep()方法，使得代码更为易读。
 
 点击(此处)折叠或打开
 
 import static java.lang.Thread.currentThread;
 import java.util.concurrent.TimeUnit;
 public class ThreadPauseDemo{
     public static void main(String args[]) throws InterruptedException {
         Game game = new Game();
         Thread t1 = new Thread(game, "T1");
         t1.start();
         // 现在停止Game线程
         System.out.println(currentThread().getName() + " is stopping game thread");
         game.stop();
         // 查看Game线程停止的状态
         TimeUnit.MILLISECONDS.sleep(200);
         System.out.println(currentThread().getName() + " is finished now");
     }
 }
 
 
 点击(此处)折叠或打开
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
 
     
 
      
 
       class 
       Game 
       implements 
       Runnable{
      
 
      
 
           
       private 
       volatile 
       boolean 
       isStopped = 
       false
       ;
      
 
      
 
           
       public 
       void 
       run(){
      
 
      
 
               
       while
       (!isStopped){
      
 
      
 
                   
       System.out.println(
       "Game thread is running......"
       );
      
 
      
 
                   
       System.out.println(
       "Game thread is now going to pause"
       );
      
 
      
 
                   
       try
       {
      
 
      
 
                       
       Thread.sleep(
       200
       );
      
 
      
 
                   
       } <a href=
       "/tags.php/catch/" 
       target=
       "_blank"
       >
       catch
       </a>(InterruptedException e){
      
 
      
 
                       
       e.printStackTrace();
      
 
      
 
                   
       }
      
 
      
 
                   
       System.out.println(
       "Game thread is now resumed......"
       );
      
 
      
 
               
       }
      
 
      
 
               
       System.out.println(
       "Game thread is stopped......"
       );
      
 
      
 
           
       }
      
 
      
 
           
       public 
       void 
       stop(){
      
 
      
 
               
       isStopped = 
       true
       ;
      
 
      
 
           
       }
      
 
      
 
       }
      
 
     
 
 
 
 
 程序输出如下：
 Game thread is running......
 main is stopping game thread
 Game thread is now going to pause
 Game thread is now resumed......
 Game thread is stopped......
 main is finished now
 
 注：
 volatile关键字：当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取这个值时，它会去主内存中读取新值。volatile关键字保证了可见性。普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
 通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
 一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么它就具备了两层语义：
 1. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
 2. 禁止进行指令重排序。
 volatile关键字禁止指令重排序有两层意思：
 1. 当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行。
 2. 在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。
 volatile一般情况下不能代替sychronized，因为volatile不能保证操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。
 
 三、sleep()方法总结
 
 Thread.sleep()方法可以让线程暂停或停止，它还有一些细节需要注意：
 1. Thread.sleep()方法是一个静态方法，它总是可以让当前的线程转入睡眠。
 2. 可以调用interrupt()方法把当前睡眠的线程唤醒。
 3. sleep()方法不能保证线程能精准地在指定那一毫秒内转入睡眠，它的精度取决于系统的计时器。
 4. 它不会释放它所获得的锁。
 
 
 
 
 如何停止java线程
 
 如何停止java的线程一直是一个困恼我们开发多线程程序的一个问题。这个问题最终在Java5的java.util.concurrent中得到了回答：使用interrupt()，让线程在run方法中停止。
 简介
 
 在Java的多线程编程中，java.lang.Thread类型包含了一些列的方法start(), stop(), stop(Throwable) and suspend(), destroy() and resume()。通过这些方法，我们可以对线程进行方便的操作，但是这些方法中，只有start()方法得到了保留。
 
 在Sun公司的一篇文章《Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 》中详细讲解了舍弃这些方法的原因。那么，我们究竟应该如何停止线程呢？
 
 
 
 
 建议使用的方法
 
 在《Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 》中，建议使用如下的方法来停止线程：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
 
     
 
      
 
           
       private 
       volatile 
       Thread blinker;
      
 
      
 
           
       public 
       void 
       stop() {
      
 
      
 
               
       blinker = 
       null
       ;
      
 
      
 
           
       }
      
 
      
 
           
       public 
       void 
       run() {
      
 
      
 
               
       Thread thisThread = Thread.currentThread();
      
 
      
 
               
       while 
       (blinker == thisThread) {
      
 
      
 
                   
       try 
       {
      
 
      
 
                       
       thisThread.sleep(interval);
      
 
      
 
                   
       } 
       catch 
       (InterruptedException e){
      
 
      
 
                   
       }
      
 
      
 
                   
       repaint();
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
     
 
 
 
 
 关于使用volatile关键字的原因，请查看http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#36930。
 当线程处于非运行（Run）状态
 
 当线程处于下面的状况时，属于非运行状态：
 
     当sleep方法被调用。
 
     当wait方法被调用。
 
     当被I/O阻塞，可能是文件或者网络等等。
 
 当线程处于上述的状态时，使用前面介绍的方法就不可用了。这个时候，我们可以使用interrupt()来打破阻塞的情况，如：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
 
     
 
      
 
       public 
       void 
       stop() {
      
 
      
 
               
       Thread tmpBlinker = blinker;
      
 
      
 
               
       blinker = 
       null
       ;
      
 
      
 
               
       if 
       (tmpBlinker != 
       null
       ) {
      
 
      
 
                  
       tmpBlinker.interrupt();
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
     
 
 
 
 
 当interrupt()被调用的时候，InterruptedException将被抛出，所以你可以再run方法中捕获这个异常，让线程安全退出：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
 
     
 
      
 
       try 
       {
      
 
      
 
          
       ....
      
 
      
 
          
       wait();
      
 
      
 
       } 
       catch 
       (InterruptedException iex) {
      
 
      
 
          
       throw 
       new 
       RuntimeException(
       "Interrupted"
       ,iex);
      
 
      
 
       }
      
 
     
 
 
 
 
 阻塞的I/O
 
 当线程被I/O阻塞的时候，调用interrupt()的情况是依赖与实际运行的平台的。在Solaris和Linux平台上将会抛出InterruptedIOException的异常，但是Windows上面不会有这种异常。所以，我们处理这种问题不能依靠于平台的实现。如：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
     

       20
     
 
     

       21
     
 
     

       22
     
 
     

       23
     
 
     

       24
     
 
     

       25
     
 
     

       26
     
 
     

       27
     
 
     

       28
     
 
     

       29
     
 
     

       30
     
 
     

       31
     
 
     

       32
     
 
     

       33
     
 
     

       34
     
 
     

       35
     
 
     

       36
     
 
     

       37
     
 
     

       38
     
 
     

       39
     
 
     

       40
     
 
     

       41
     
 
     

       42
     
 
     

       43
     
 
     

       44
     
 
     

       45
     
 
     

       46
     
 
     

       47
     
 
     

       48
     
 
     

       49
     
 
     

       50
     
 
 
     
 
      
 
       package 
       com.cnblogs.gpcuster
      
 
      
 
       import 
       java.net.*;
      
 
      
 
       import 
       java.io.*;
      
 
      
 
       public 
       abstract 
       class 
       InterruptibleReader 
       extends 
       Thread {
      
 
      
 
           
       private 
       Object lock = 
       new 
       Object( );
      
 
      
 
           
       private 
       InputStream is;
      
 
      
 
           
       private 
       boolean 
       done;
      
 
      
 
           
       private 
       int 
       buflen;
      
 
      
 
           
       protected 
       void 
       processData(
       byte
       [] b, 
       int 
       n) { }
      
 
      
 
           
       class 
       ReaderClass 
       extends 
       Thread {
      
 
      
 
               
       public 
       void 
       run( ) {
      
 
      
 
                   
       byte
       [] b = 
       new 
       byte
       [buflen];
      
 
      
 
                   
       while 
       (!done) {
      
 
      
 
                       
       try 
       {
      
 
      
 
                           
       int 
       n = is.read(b, 
       0
       , buflen);
      
 
      
 
                           
       processData(b, n);
      
 
      
 
                       
       } 
       catch 
       (IOException ioe) {
      
 
      
 
                           
       done = 
       true
       ;
      
 
      
 
                       
       }
      
 
      
 
                   
       }
      
 
      
 
                   
       synchronized
       (lock) {
      
 
      
 
                       
       lock.notify( );
      
 
      
 
                   
       }
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
      
 
           
       public 
       InterruptibleReader(InputStream is) {
      
 
      
 
               
       this
       (is, 
       512
       );
      
 
      
 
           
       }
      
 
      
 
           
       public 
       InterruptibleReader(InputStream is, 
       int 
       len) {
      
 
      
 
               
       this
       .is = is;
      
 
      
 
               
       buflen = len;
      
 
      
 
           
       }
      
 
      
 
           
       public 
       void 
       run( ) {
      
 
      
 
               
       ReaderClass rc = 
       new 
       ReaderClass( );
      
 
      
 
               
       synchronized
       (lock) {
      
 
      
 
                   
       rc.start( );
      
 
      
 
                   
       while 
       (!done) {
      
 
      
 
                       
       try 
       {
      
 
      
 
                           
       lock.wait( );
      
 
      
 
                       
       } 
       catch 
       (InterruptedException ie) {
      
 
      
 
                           
       done = 
       true
       ;
      
 
      
 
                           
       rc.interrupt( );
      
 
      
 
                           
       try 
       {
      
 
      
 
                               
       is.close( );
      
 
      
 
                           
       } 
       catch 
       (IOException ioe) {}
      
 
      
 
                       
       }
      
 
      
 
                   
       }
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
      
 
       }
      
 
     
 
 
 
 
 
 另外，我们也可以使用InterruptibleChannel接口。 实现了InterruptibleChannel接口的类可以在阻塞的时候抛出ClosedByInterruptException。如：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
     

       20
     
 
     

       21
     
 
     

       22
     
 
     

       23
     
 
     

       24
     
 
     

       25
     
 
     

       26
     
 
     

       27
     
 
     

       28
     
 
     

       29
     
 
     

       30
     
 
     

       31
     
 
     

       32
     
 
     

       33
     
 
     

       34
     
 
     

       35
     
 
     

       36
     
 
     

       37
     
 
     

       38
     
 
     

       39
     
 
     

       40
     
 
     

       41
     
 
     

       42
     
 
     

       43
     
 
     

       44
     
 
     

       45
     
 
 
     
 
      
 
       package 
       com.cnblogs.gpcuster
      
 
      
 
       import 
       java.io.BufferedReader;
      
 
      
 
       import 
       java.io.FileDescriptor;
      
 
      
 
       import 
       java.io.FileInputStream;
      
 
      
 
       import 
       java.io.InputStream;
      
 
      
 
       import 
       java.io.InputStreamReader;
      
 
      
 
       import 
       java.nio.channels.Channels;
      
 
      
 
       public 
       class 
       InterruptInput {   
      
 
      
 
           
       static 
       BufferedReader in = 
       new 
       BufferedReader(
      
 
      
 
                   
       new 
       InputStreamReader(
      
 
      
 
                   
       Channels.newInputStream(
      
 
      
 
                   
       (
       new 
       FileInputStream(FileDescriptor.in)).getChannel())));
      
 
      
 
            
      
 
      
 
           
       public 
       static 
       void 
       main(String args[]) {
      
 
      
 
               
       try 
       {
      
 
      
 
                   
       System.out.println(
       "Enter lines of input (user ctrl+Z Enter to terminate):"
       );
      
 
      
 
                   
       System.out.println(
       "(Input thread will be interrupted in 10 sec.)"
       );
      
 
      
 
                   
       // interrupt input in 10 sec
      
 
      
 
                   
       (
       new 
       TimeOut()).start();
      
 
      
 
                   
       String line = 
       null
       ;
      
 
      
 
                   
       while 
       ((line = in.readLine()) != 
       null
       ) {
      
 
      
 
                       
       System.out.println(
       "Read line:'"
       +line+
       "'"
       );
      
 
      
 
                   
       }
      
 
      
 
               
       } 
       catch 
       (Exception ex) {
      
 
      
 
                   
       System.out.println(ex.toString()); 
       // printStackTrace();
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
      
 
            
      
 
      
 
           
       public 
       static 
       class 
       TimeOut 
       extends 
       Thread {
      
 
      
 
               
       int 
       sleepTime = 
       10000
       ;
      
 
      
 
               
       Thread threadToInterrupt = 
       null
       ;    
      
 
      
 
               
       public 
       TimeOut() {
      
 
      
 
                   
       // interrupt thread that creates this TimeOut.
      
 
      
 
                   
       threadToInterrupt = Thread.currentThread();
      
 
      
 
                   
       setDaemon(
       true
       );
      
 
      
 
               
       }
      
 
      
 
                
      
 
      
 
               
       public 
       void 
       run() {
      
 
      
 
                   
       try 
       {
      
 
      
 
                       
       sleep(
       10000
       ); 
       // wait 10 sec
      
 
      
 
                   
       } 
       catch
       (InterruptedException ex) {
       /*ignore*/
       }
      
 
      
 
                   
       threadToInterrupt.interrupt();
      
 
      
 
               
       }
      
 
      
 
           
       }
      
 
      
 
       }
      
 
     
 
 
 
 
 这里还需要注意一点，当线程处于写文件的状态时，调用interrupt()不会中断线程。
 
 
 
 如何正确停止java中的线程 
 
 为什么不能使用Thread.stop()方法？
 
 从SUN的官方文档可以得知，调用Thread.stop()方法是不安全的，这是因为当调用Thread.stop()方法时，会发生下面两件事：
 
 1. 即刻抛出ThreadDeath异常，在线程的run()方法内，任何一点都有可能抛出ThreadDeath Error，包括在catch或finally语句中。
 2. 释放该线程所持有的所有的锁
 
 
 当线程抛出ThreadDeath异常时，会导致该线程的run()方法突然返回来达到停止该线程的目的。ThreadDetath异常可以在该线程run()方法的任意一个执行点抛出。但是，线程的stop()方法一经调用线程的run()方法就会即刻返回吗？
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
     

       20
     
 
     

       21
     
 
     

       22
     
 
     

       23
     
 
     

       24
     
 
     

       25
     
 
     

       26
     
 
     

       27
     
 
     

       28
     
 
     

       29
     
 
     

       30
     
 
     

       31
     
 
     

       32
     
 
     

       33
     
 
     

       34
     
 
     

       35
     
 
     

       36
     
 
     

       37
     
 
     

       38
     
 
     

       39
     
 
     

       40
     
 
     

       41
     
 
     

       42
     
 
     

       43
     
 
     

       44
     
 
     

       45
     
 
     

       46
     
 
     

       47
     
 
     

       48
     
 
     

       49
     
 
     

       50
     
 
 
     
 
      
 
       public 
       static 
       void 
       main(String[] args) {   
      
 
      
 
               
       try 
       {   
      
 
      
 
                   
       Thread t = 
       new 
       Thread() {   
      
 
      
 
                       
       public 
       synchronized 
       void 
       run() {   
      
 
      
 
                           
       try 
       {   
      
 
      
 
                               
       long 
       start=System.currentTimeMillis();   
      
 
      
 
                               
       for 
       (
       int 
       i = 
       0
       ; i < 
       100000
       ; i++)   
      
 
      
 
                                   
       System.out.println(
       "runing.." 
       + i);   
      
 
      
 
                               
       System.out.println((System.currentTimeMillis()-start)/
       1000
       );   
      
 
      
 
                           
       } 
       catch 
       (Throwable ex) {   
      
 
      
 
                               
       System.out.println(
       "Caught in run: " 
       + ex);   
      
 
      
 
                               
       ex.printStackTrace();   
      
 
      
 
                           
       }   
      
 
      
 
                       
       }   
      
 
      
 
                   
       };   
      
 
      
 
                   
       t.start();   
      
 
      
 
                   
       // Give t time to get going...   
      
 
      
 
                   
       Thread.sleep(
       100
       );   
      
 
      
 
                   
       t.stop(); 
       // EXPECT COMPILER WARNING   
      
 
      
 
               
       } 
       catch 
       (Throwable t) {   
      
 
      
 
                   
       System.out.println(
       "Caught in main: " 
       + t);   
      
 
      
 
                   
       t.printStackTrace();   
      
 
      
 
               
       }   
      
 
      
 
          
      
 
      
 
           
       }  
      
 
      
 
       public 
       static 
       void 
       main(String[] args) {  
      
 
      
 
               
       try 
       {  
      
 
      
 
                   
       Thread t = 
       new 
       Thread() {  
      
 
      
 
                       
       public 
       synchronized 
       void 
       run() {  
      
 
      
 
                           
       try 
       {  
      
 
      
 
                               
       long 
       start=System.currentTimeMillis();  
      
 
      
 
                               
       for 
       (
       int 
       i = 
       0
       ; i < 
       100000
       ; i++)  
      
 
      
 
                                   
       System.out.println(
       "runing.." 
       + i);  
      
 
      
 
                               
       System.out.println((System.currentTimeMillis()-start)/
       1000
       );  
      
 
      
 
                           
       } 
       catch 
       (Throwable ex) {  
      
 
      
 
                               
       System.out.println(
       "Caught in run: " 
       + ex);  
      
 
      
 
                               
       ex.printStackTrace();  
      
 
      
 
                           
       }  
      
 
      
 
                       
       }  
      
 
      
 
                   
       };  
      
 
      
 
                   
       t.start();  
      
 
      
 
                   
       // Give t time to get going...  
      
 
      
 
                   
       Thread.sleep(
       100
       );  
      
 
      
 
                   
       t.stop(); 
       // EXPECT COMPILER WARNING  
      
 
      
 
               
       } 
       catch 
       (Throwable t) {  
      
 
      
 
                   
       System.out.println(
       "Caught in main: " 
       + t);  
      
 
      
 
                   
       t.printStackTrace();  
      
 
      
 
               
       }  
      
 
      
 
          
      
 
      
 
           
       }
      
 
     
 
 
 
 
 假设我们有如上一个工作线程，它的工作是数数，从1到1000000，我们的目标是在它进行数数的过程中，停止该线程的运作。如果我们按照上面的方式来调用thread.stop()方法，原则上是可以实现我们的目标的，根据SUN官方文档的解释，加上在上面的程序中，主线程只休眠了100ms，而工作线程从1数到1000000所花时间大概是4-5s，那么该工作线程应该只从1数到某个值（小于1000000），然后线程停止。 
 
 但是根据运行结果来看，并非如此。
 
 结果：
 
 。。。
 
 runing..99998
 runing..99999
 
 5
 
 。。。
 
 runing..99998
 runing..99999
 4
 
 每次运行的结果都表明，工作线程并没有停止，而是每次都成功的数完数，然后正常中止，而不是由stop()方法进行终止的。这个是为什么呢？根据SUN的文档，原则上只要一调用thread.stop()方法，那么线程就会立即停止，并抛出ThreadDeath error，查看了Thread的源代码后才发现，原先Thread.stop0()方法是同步的，而我们工作线程的run()方法也是同步，那么这样会导致主线程和工作线程共同争用同一个锁（工作线程对象本身），由于工作线程在启动后就先获得了锁，所以无论如何，当主线程在调用t.stop()时，它必须要等到工作线程的run()方法执行结束后才能进行，结果导致了上述奇怪的现象。
 
 把上述工作线程的run()方法的同步去掉，再进行执行，结果就如上述第一点描述的那样了
 
 可能的结果：
 
 runing..4149
 runing..4150
 runing..4151
 runing..4152runing..4152Caught in run: java.lang.ThreadDeath
 
 或者
 
 runing..5245
 runing..5246
 runing..5247
 runing..5248runing..5248Caught in run: java.lang.ThreadDeath
 
 
 接下来是看看当调用thread.stop()时，被停止的线程会不会释放其所持有的锁，看如下代码：
 
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
     

       20
     
 
     

       21
     
 
     

       22
     
 
     

       23
     
 
     

       24
     
 
     

       25
     
 
     

       26
     
 
     

       27
     
 
     

       28
     
 
     

       29
     
 
     

       30
     
 
     

       31
     
 
     

       32
     
 
     

       33
     
 
     

       34
     
 
     

       35
     
 
     

       36
     
 
     

       37
     
 
     

       38
     
 
     

       39
     
 
     

       40
     
 
     

       41
     
 
     

       42
     
 
     

       43
     
 
     

       44
     
 
     

       45
     
 
     

       46
     
 
     

       47
     
 
     

       48
     
 
     

       49
     
 
     

       50
     
 
     

       51
     
 
     

       52
     
 
     

       53
     
 
     

       54
     
 
     

       55
     
 
     

       56
     
 
     

       57
     
 
     

       58
     
 
     

       59
     
 
     

       60
     
 
     

       61
     
 
     

       62
     
 
     

       63
     
 
     

       64
     
 
     

       65
     
 
     

       66
     
 
     

       67
     
 
     

       68
     
 
     

       69
     
 
     

       70
     
 
     

       71
     
 
     

       72
     
 
     

       73
     
 
     

       74
     
 
     

       75
     
 
     

       76
     
 
     

       77
     
 
     

       78
     
 
 
     
 
      
 
       public 
       static 
       void 
       main(String[] args) {   
      
 
      
 
               
       final 
       Object lock = 
       new 
       Object();   
      
 
      
 
               
       try 
       {   
      
 
      
 
                   
       Thread t0 = 
       new 
       Thread() {   
      
 
      
 
                       
       public 
       void 
       run() {   
      
 
      
 
                           
       try 
       {   
      
 
      
 
                               
       synchronized 
       (lock) {   
      
 
      
 
                                   
       System.out.println(
       "thread->" 
       + getName()   
      
 
      
 
                                           
       + 
       " acquire lock."
       );   
      
 
      
 
                                   
       sleep(
       3000
       );
       // sleep for 3s   
      
 
      
 
                                   
       System.out.println(
       "thread->" 
       + getName()   
      
 
      
 
                                           
       + 
       " release lock."
       );   
      
 
      
 
                               
       }   
      
 
      
 
                           
       } 
       catch 
       (Throwable ex) {   
      
 
      
 
                               
       System.out.println(
       "Caught in run: " 
       + ex);   
      
 
      
 
                               
       ex.printStackTrace();   
      
 
      
 
                           
       }   
      
 
      
 
                       
       }   
      
 
      
 
                   
       };   
      
 
      
 
          
      
 
      
 
                   
       Thread t1 = 
       new 
       Thread() {   
      
 
      
 
                       
       public 
       void 
       run() {   
      
 
      
 
                           
       synchronized 
       (lock) {   
      
 
      
 
                               
       System.out.println(
       "thread->" 
       + getName()   
      
 
      
 
                                       
       + 
       " acquire lock."
       );   
      
 
      
 
                           
       }   
      
 
      
 
                       
       }   
      
 
      
 
                   
       };   
      
 
      
 
          
      
 
      
 
                   
       t0.start();   
      
 
      
 
                   
       // Give t time to get going...   
      
 
      
 
                   
       Thread.sleep(
       100
       );   
      
 
      
 
                   
       //t0.stop();   
      
 
      
 
                   
       t1.start();   
      
 
      
 
               
       } 
       catch 
       (Throwable t) {   
      
 
      
 
                   
       System.out.println(
       "Caught in main: " 
       + t);   
      
 
      
 
                   
       t.printStackTrace();   
      
 
      
 
               
       }   
      
 
      
 
          
      
 
      
 
           
       }  
      
 
      
 
                
      
 
      
 
       public 
       static 
       void 
       main(String[] args) {  
      
 
      
 
           
       final 
       Object lock = 
       new 
       Object();  
      
 
      
 
           
       try 
       {  
      
 
      
 
               
       Thread t0 = 
       new 
       Thread() {  
      
 
      
 
                   
       public 
       void 
       run() {  
      
 
      
 
                       
       try 
       {  
      
 
      
 
                           
       synchronized 
       (lock) {  
      
 
      
 
                               
       System.out.println(
       "thread->" 
       + getName()  
      
 
      
 
                                       
       + 
       " acquire lock."
       );  
      
 
      
 
                               
       sleep(
       3000
       );
       // sleep for 3s  
      
 
      
 
                               
       System.out.println(
       "thread->" 
       + getName()  
      
 
      
 
                                       
       + 
       " release lock."
       );  
      
 
      
 
                           
       }  
      
 
      
 
                       
       } 
       catch 
       (Throwable ex) {  
      
 
      
 
                           
       System.out.println(
       "Caught in run: " 
       + ex);  
      
 
      
 
                           
       ex.printStackTrace();  
      
 
      
 
                       
       }  
      
 
      
 
                   
       }  
      
 
      
 
               
       };  
      
 
      
 
               
       Thread t1 = 
       new 
       Thread() {  
      
 
      
 
                   
       public 
       void 
       run() {  
      
 
      
 
                       
       synchronized 
       (lock) {  
      
 
      
 
                           
       System.out.println(
       "thread->" 
       + getName()  
      
 
      
 
                                   
       + 
       " acquire lock."
       );  
      
 
      
 
                       
       }  
      
 
      
 
                   
       }  
      
 
      
 
               
       };  
      
 
      
 
               
       t0.start();  
      
 
      
 
               
       // Give t time to get going...  
      
 
      
 
               
       Thread.sleep(
       100
       );  
      
 
      
 
               
       //t0.stop();  
      
 
      
 
               
       t1.start();  
      
 
      
 
           
       } 
       catch 
       (Throwable t) {  
      
 
      
 
               
       System.out.println(
       "Caught in main: " 
       + t);  
      
 
      
 
               
       t.printStackTrace();  
      
 
      
 
           
       }  
      
 
      
 
       }
      
 
     
 
 
 
 
 
 当没有进行t0.stop()方法的调用时， 可以发现，两个线程争用锁的顺序是固定的。
 
 输出：
 
 thread->Thread-0 acquire lock.
 thread->Thread-0 release lock.
 thread->Thread-1 acquire lock.
 
 
 但调用了t0.stop()方法后，（去掉上面的注释//t0.stop();），可以发现，t0线程抛出了ThreadDeath error并且t0线程释放了它所占有的锁。
 
 
 输出：
 
 thread->Thread-0 acquire lock.
 thread->Thread-1 acquire lock.
 Caught in run: java.lang.ThreadDeath
 java.lang.ThreadDeath
  at java.lang.Thread.stop(Thread.java:715)
  at com.yezi.test.timeout.ThreadStopTest.main(ThreadStopTest.java:40)
 
 从上面的程序验证结果来看，thread.stop()确实是不安全的。它的不安全主要是针对于第二点：释放该线程所持有的所有的锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。
 
 
 如何正确停止线程
 
 关于如何正确停止线程，这篇文章(how to stop thread)给出了一个很好的答案, 总结起来就下面3点（在停止线程时）：
 
 1. 使用violate boolean变量来标识线程是否停止
 2. 停止线程时，需要调用停止线程的interrupt()方法，因为线程有可能在wait()或sleep(), 提高停止线程的即时性
 3. 对于blocking IO的处理，尽量使用InterruptibleChannel来代替blocking IO
  
 
 核心如下：
 
 
 
 
 
     

       1
     
 
     

       2
     
 
     

       3
     
 
     

       4
     
 
     

       5
     
 
     

       6
     
 
     

       7
     
 
     

       8
     
 
     

       9
     
 
     

       10
     
 
     

       11
     
 
     

       12
     
 
     

       13
     
 
     

       14
     
 
     

       15
     
 
     

       16
     
 
     

       17
     
 
     

       18
     
 
     

       19
     
 
     

       20
     
 
     

       21
     
 
     

       22
     
 
     

       23
     
 
     

       24
     
 
     

       25
     
 
     

       26
     
 
     

       27
     
 
 
     
 
      
 
       If you are writing your own small thread then you should follow the following example code.
      
 
      
 
       private 
       volatile 
       Thread myThread;
      
 
      
 
       public 
       void 
       stopMyThread() {
      
 
      
 
           
       Thread tmpThread = myThread;
      
 
      
 
           
       myThread = 
       null
       ;
      
 
      
 
           
       if 
       (tmpThread != 
       null
       ) {
      
 
      
 
               
       tmpThread.interrupt();
      
 
      
 
           
       }
      
 
      
 
       }
      
 
      
 
       public 
       void 
       run() {
      
 
      
 
           
       if 
       (myThread == 
       null
       ) {
      
 
      
 
              
       return
       ; 
       // stopped before started.
      
 
      
 
           
       }
      
 
      
 
           
       try 
       {
      
 
      
 
               
       // all the run() method's code goes here
      
 
      
 
               
       ...
      
 
      
 
               
       // do some work
      
 
      
 
               
       Thread.yield(); 
       // let another thread have some time perha<a href="/fw/photo.html" target="_blank">ps</a> to stop this one.
      
 
      
 
               
       if 
       (Thread.currentThread().isInterrupted()) {
      
 
      
 
                  
       throw 
       new 
       InterruptedException(
       "Stopped by ifInterruptedStop()"
       );
      
 
      
 
               
       }
      
 
      
 
               
       // do some more work
      
 
      
 
               
       ...
      
 
      
 
           
       } 
       catch 
       (Throwable t) {
      
 
      
 
              
       // log/handle all errors here
      
 
      
 
           
       }
      
 
      
 
       }
      
 
      

       
 
      
 
     
 
 

写一个效果为点击后跳出一个弹框，在3秒后自动右移消失，这个弹框的下面还有一条进度条，在这三秒的时候逐渐减小，在进度条消失的时候弹框便会开始右移。
 
为这个弹框添加一个鼠标mouseover，计数清零，进度框的animate也停止并回退，设计如图：
 
 

$(".popup").mouseover(function(){
     clearInterval(timer);
     $(".progress").stop()；
})
.popup就是弹框，.progress是进度条

 
 
为.progress添加stop(),
 
stop(stopAll,goToEnd)
 
stopAll——停止该元素当前所有的animate动作
 
goToEnd——结束该元素当前的animate动作后停止
 
就是倘若该元素就较多的动作，有好多个animate，那么stopAll的意思就是所有的animate直接停止，而goToEnd的意思就是当前的这个animate先结束，然后再停止。
 
注:goToEnd只能在设置了 stopAll 参数时使用。

 当电脑安装了数据库服务（如，Oracle、SQLServer）或一些web服务(如IIS，tomcat)时，系统会添加很多服务（services）项。而这些服务往往是占用很大的系统资源的。如果在平时不用的时候一直处于启动状态是对系统资源的极大浪费。所以我们就通过“管理工具”中的“服务”将所有不必要的服务停止。但是每次用到的时候或不用的时候手工去启动和停止比较麻烦。用批理来操作会方便很多。
 下面介绍两种使用批处理操作来 设置、启动和停止服务的方法。 
 从Windows XP开始，其自带的DOS工具中加入了一个sc.exe（Service Control）和net.exe (C:/WINDOWS/system32)的文件，恰好可以对服务的启动类型以及服务的启动或者关闭等进行操作，再利用DOS的批处理优势，就可以把上面提到的操作进行简化。
 方法 一： 
 sc.exe常用功能:
 1、更改服务的启动状态. sc config 服务名 start= 属性（demand 手动、auto 自动、disable 禁用） 设置该服务的启动形式(= 后面有个空格)
 2、删除服务（否则不建议删除任何系统服务，特别是基础服务 慎用） 
 3、停止或启动服务（功能上类似于net stop/start，但速度更快且能停止的服务更多）
 
 具体的命令格式： 
 修改服务启动类型的命令行格式为（特别注意start=后面有一个空格） 
 sc config 服务名称 start= demand（设置服务为手动启动） 
 sc config 服务名称 start= auto（设置服务为自动启动） 
 sc config 服务名称 start= disabled（设置服务为禁用）
 停止/启动服务的命令行格式为 
 sc start 服务名称
 sc stop 服务名称 
 注意：服务名称：可以在控制面板->管理工具->服务里面，双击对应的服务显示名来查询。 
 例： 
 设置远程注册表服务为手动其格式为 
 sc config RemoteRegistry start= demand 
 设为禁用的格式为 
 sc config RemoteRegistry start= disabled 
 停止服务则格式为 
 sc stop RemoteRegistry
 方法二： 
 使用net.exe功能启动或停止服务
 启动/停止 服务的命令行格式为 
 net start 服务名称
 net stop 服务名称 
 例： 
 以启动和停止Oracle服务为例：由于Oracle服务非常占用系统资源，而且平时不怎么用Oracle数据库。所以我将其设为手动启动，然后每次用到Oracle时，使用批处理来启动一堆服务。
 -- 开始Oracle的服务 
 @echo off 
 net start OracleMTSRecoveryService 
 net start OracleOraHome92Agent 
 net start OracleOraHome92TNSListener 
 net start OracleService数据库名 
 -- 停止Oracle的服务 
 @echo off 
 net stop OracleService数据库名 
 net stop OracleOraHome92TNSListener 
 net stop OracleOraHome92Agent 
 net stop OracleMTSRecoveryService
 启动方法： 
 方法1.保存之后便可以直接通过双击文件即可启动或者关闭服务 
 方法2.设置环境变量 
 在环境变量中的系统变量中，在PATH后面添加批处理文件的路径，不要忘记用分号;和前面的环境变量隔开，然后直接在开始菜单中的运行中输入可执行相应的文件 
 环境变量的作用就是告诉系统在运行中输入信息的位置而已。
 注意：在vista,win7等系统有时直接运行bat文件，很多服务启动不了，会提示拒绝访问等，是因为权限问题，在运行bat文件时要以管理员身份运行即可。
 
 net start 服务名 开启某服务
 net stop 服务名 关闭某服务
 注：如果服务名有空格，则用双引号括起来。另外服务名不是服务显示的名称，你要右键服务属性才能看到服务名。有时候显示的名称就是服务名。
 常用一些服务的启动停止
 ---sqlserver 相关服务启动---
 @echo.服务启动...... 
 @echo off 
 @sc start MSSQLSERVER 
 @sc start SQLSERVERAGENT 
 @sc start MSSQLServerOLAPService 
 @sc start msftesql 
 @sc start MsDtsServer 
 @sc start SQLWriter 
 @echo off 
 @echo.启动完毕！ 
 @pause
 ---sqlserver 相关服务停止---
 @echo.服务停止...... 
 @echo off 
 @sc stop SQLSERVERAGENT 
 @sc stop MSSQLServerOLAPService 
 @sc stop msftesql 
 @sc stop MsDtsServer 
 @sc stop SQLWriter 
 @sc stop MSSQLSERVER 
 @echo off 
 @echo.停止完毕！ 
 @pause
 注：每行命令前有个@，没有也可以
 选择性启动一些服务
 @echo off
 rem echo (备注： 自动：auto 手动启动：demand 禁用：disabled )
 sc config knbcenter start=disabled
 sc config PPTVService start=disabled
 sc config 360rp start=disabled
 sc config BFAssistantSvc start=disabled
 (net stop knbcenter)&(net stop PPTVService)&(net stop 360rp)&(net stop BFAssistantSvc)
 echo 已禁用服务：猎豹浏览器安全中心、PPTVService、360rp、BFAssistantSvc..
 echo 选择要开启的服务：
 echo.
 echo 0 全部
 echo 1 猎豹浏览器安全中心
 echo 2 PPTVService
 echo 3 360杀毒实时防护
 echo 4 BFAssistantSvc
 echo.
 set/p var=请选择要开启的服务序号:
 if %var%==0 (net start knbcenter)&(net start PPTVService)&(net start 360rp)&(net start BFAssistantSvc)
 if %var%==1 net start knbcenter
 if %var%==2 net start PPTVService
 if %var%==3 net start 360rp
 if %var%==4 net start BFAssistantSvc
 pause
 IIS相关
 IIS重新启动的dos命令：iisreset /restart
 启动IIS： 
 net start iisadmin （IIS的整个服务）
 net start w3svc （WWW网页WEB服务）
 停止IIS： 
 net stop iisadmin /y （会自动停止www、ftp和smtp服务）
 如果用的IIS自带FTP还可以执行
 net start MSFtpsvc
 命令来启动FTP
 
 以上命令放到bat文件中,再结合windows的任务计划就可以实现调度
 自动打开和关闭IE浏览器
 使用批处理命令实现自动打开和关闭IE浏览器，把如下两行#号里的内容全部复制，粘贴到记事本，保存为*.bat文件(*号为文件名)。运行即可。
 #####################
 ping 127.1 -n 3 >nul 
 rem 延时3秒 
 @echo off 
 rem 关闭回显命令 
 cd C:\Program Files\Internet Explorer\ 
 rem 改变当前目录到IE所在目录 
 rem 打开ie,30秒后关闭 
 start iexplore.exe http://localhost:8090/
 rem 启动IE 执行加载路由连接程序 以上地址为例 
 ping 127.1 -n 30 >nul 
 rem 延时30秒 
 taskkill /im iexplore.exe /f 
 rem 关闭IE 
 rem 加载路由成功结束 
 
 #####################
 -----另外附一个清理垃圾的bat文件 清理电脑中的垃圾文件.bat---
 @echo off 
 echo 正在清除系统垃圾文件，请稍等...... 
 del /f /s /q %systemdrive%\*.tmp 
 del /f /s /q %systemdrive%\*._mp 
 del /f /s /q %systemdrive%\*.log 
 del /f /s /q %systemdrive%\*.gid 
 del /f /s /q %systemdrive%\*.chk 
 del /f /s /q %systemdrive%\*.old 
 del /f /s /q %systemdrive%\recycled\*.* 
 del /f /s /q %windir%\*.bak 
 del /f /s /q %windir%\prefetch\*.* 
 rd /s /q %windir%\temp & md %windir%\temp 
 del /f /q %userprofile%\cookies\*.* 
 del /f /q %userprofile%\recent\*.* 
 del /f /s /q "%userprofile%\Local Settings\Temporary Internet Files\*.*" 
 del /f /s /q "%userprofile%\Local Settings\Temp\*.*" 
 del /f /s /q "%userprofile%\recent\*.*" 
 echo 清除系统垃圾文件完成！ 
 echo. & pause
 @echo off 是关闭命令回显
 批量运行exe,bat文件
 .\packet\dotnetfx35.exe /passive
 .\packet\WindowsXP-KB968930-x86-ENG.exe /passive /norestart
 .\packet\WindowsXP-KB942288-v3-x86.exe /passive /forcerestart
 
 把上面的写在一个文本文件中，存成.bat文件，在同级目录下建一个packet的文件夹，里面放入上面三个路径中的exe文件，运行该bat文件则可以自动运行这三个文件，/passive 是运行选项，有哪些选项可以用　可以在命令行中输入　****.exe 文件　/?则可以看到所有可用选项
 /norestart 是不重启的意思　　 
 /forcerestart　是强制重启
 如果想批处理运行一系列的exe文件，均可以这么做
 适合用在批量运行一系列exe文件时，如批量安装，安装补丁包
 上面有一个问题就是会按顺序一个一个执行，第一个运行完才开始第二个，有时需要按顺序执行一系列的exe,bat文件，或者说同时打开则可以这样
 :echo 'automatchworker'
 start AutoMatchWorker.bat
 :echo 'ScheduleWorker'
 start ScheduleWorker.bat
 :echo 'SmsWork'
 start SmsWorker.bat
 :echo 'NotificationWorker'
 start NotificationWorker.bat
 就会“同时”打开四个程序
 
 完整的一个例子如下
 echo 'kill exe'
 taskkill /f /im NotificationWorker.exe
 echo 'copy new exe'
 XCOPY /y D:\ManagerTools\NotificationWorker D:\Workering\PushNotificationWorker
 echo 'start exe'
 ::echo 'PushNotificationWorker'
 start PushNotificationWorker.exe
 先杀掉已运行的exe
 copy 新的程序 /y 表示不用提示覆盖
 再开启
 --------选择性启动某些服务-------
 把下面两行#号中间的复制到bat文件中，双击运行即可
 #########
 
 @echo off
 
 title 各种服务开启、关闭程序 
 
 :allstart
 
 cls
 
 echo 请选择下面的编号来启动相应的服务
 
 echo 1.VMware 服务开启、关闭
 
 echo 2.SQL Server 2008 服务开启、关闭
 
 echo 3.MySQL 服务开启、关闭
 
 echo 4.Oracle XE 服务开启、关闭
 
 echo 5.Teamviewer 服务开启、关闭
 
 echo 6.Alipay 支付宝 服务开启、关闭
 
 echo e.退出
 
 set in=
 
 set /p in=请输入:
 
 if "%in%"=="1" goto vmware
 
 if "%in%"=="2" goto sqlserver
 
 if "%in%"=="3" goto mysql
 
 if "%in%"=="4" goto oraclexe
 
 if "%in%"=="5" goto teamviewer
 
 if "%in%"=="6" goto alipay
 
 if "%in%"=="e" goto allclose
 
 rem VMware服务开启、关闭
 
 :vmware
 
 echo 1.开启vm服务，2.关闭vm服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto vmstart
 
 if "%in%"=="2" goto vmstop
 
 if "%in%"=="3" goto vmsd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose
 
 :vmstart
 
 echo "正在启动VMware相关开机服务..."
 
 rem net start ufad-ws60
 
 net start VMAuthdService
 
 net start VMnetDHCP
 
 net start "VMware NAT Service"
 
 net start VMUSBArbServicepause
 
 echo 服务启动完毕!
 
 goto vmware
 
 :vmstop
 
 echo "正在关闭VMware相关开机服务..."
 
 rem net stop ufad-ws60
 
 net stop VMAuthdService
 
 net stop VMnetDHCP
 
 net stop "VMware NAT Service"
 
 net stop VMUSBArbService
 
 echo 服务已关闭!
 
 goto vmware
 
 :vmsd
 
 echo "切换VMware开机启动服务为手动中,请稍候..."
 
 sc config VMAuthdService start= demand
 
 sc config VMnetDHCP start= demand
 
 sc config "VMware NAT Service" start= demand
 
 sc config VMUSBArbService start= demand
 
 echo 成功切换为手动模式!
 
 goto vmware
 
 rem SQL Server 2008服务开启、关闭
 
 :sqlserver
 
 echo 1.开启SQLServer服务，2.关SQLServer服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto sqlserverstart
 
 if "%in%"=="2" goto sqlserverstop
 
 if "%in%"=="3" goto sqlserversd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose
 
 :sqlserverstart
 
 echo "正在开启SQL Server相关开机服务"
 
 rem SQL Server 代理 (MSSQLSERVER2008)
 
 net start SQLAgent$MSSQLSERVER2008
 
 rem SQL Full-text Filter Daemon Launcher (MSSQLSERVER2008)
 
 net start MSSQLFDLauncher$MSSQLSERVER2008
 
 rem SQL Server (MSSQLSERVER2008)
 
 net start MSSQL$MSSQLSERVER2008
 
 rem SQL Server Browser
 
 net start SQLBrowser
 
 rem SQL Server Integration Services 10.0
 
 net start MsDtsServer100
 
 rem SQL Server VSS Writer
 
 net start SQLWriter
 
 goto sqlserver
 
 :sqlserverstop
 
 echo "正在关闭SQL Server相关开机服务"
 
 net stop SQLAgent$MSSQLSERVER2008
 
 net stop MSSQLFDLauncher$MSSQLSERVER2008
 
 net stop MSSQL$MSSQLSERVER2008
 
 net stop SQLBrowser
 
 net stop MsDtsServer100
 
 net stop SQLWriter
 
 goto sqlserver
 
 :sqlserversd
 
 echo "切换SQL Server开机启动服务为手动中"
 
 sc config SQLAgent$MSSQLSERVER2008 start= demand
 
 sc config MSSQLFDLauncher$MSSQLSERVER2008 start= demand
 
 sc config MSSQL$MSSQLSERVER2008 start= demand
 
 sc config SQLBrowser start= demand
 
 sc config MsDtsServer100 start= demand
 
 sc config SQLWriter start= demand
 
 echo 成功切换为手动模式
 
 goto sqlserver
 
 rem MySQL服务开启、关闭
 
 :mysql
 
 echo 1.开启mysql服务，2.关闭mysql服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto mysqlstart
 
 if "%in%"=="2" goto mysqlstop
 
 if "%in%"=="3" goto mysqlsd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose
 
 :mysqlstart
 
 echo "正在启动MySQL相关开机服务..."
 
 net start MySQL55
 
 echo 服务启动完毕!
 
 goto mysql
 
 :mysqlstop
 
 echo "正在关闭MySQL相关开机服务..."
 
 net stop MySQL55
 
 echo 服务已关闭!
 
 goto mysql
 
 :mysqlsd
 
 echo "切换MySQL开机启动服务为手动中,请稍候..."
 
 sc config MySQL55 start= demand
 
 echo 成功切换为手动模式!
 
 goto mysql
 
 rem Oracle XE 服务开启、关闭
 
 :oraclexe
 
 echo 1.开启oraclexe必要服务，2.关闭oraclexe必要服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto oraclexestart
 
 if "%in%"=="2" goto oraclexestop
 
 if "%in%"=="3" goto oraclexesd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose1
 
 :oraclexestart
 
 echo "正在启动oracle xe 必要服务..."
 
 net start OracleMTSRecoveryService
 
 net start OracleXETNSListener
 
 net start OracleServiceXE
 
 echo 服务启动完毕!
 
 goto oraclexe
 
 :oraclexestop
 
 echo "正在关闭oracle xe相关开机服务..."
 
 net stop OracleMTSRecoveryService
 
 net stop OracleXETNSListener
 
 net stop OracleServiceXE
 
 echo 服务已关闭!
 
 goto oraclexe
 
 :oraclexesd
 
 echo "切换oracle xe开机启动服务为手动中,请稍候..."
 
 sc config OracleMTSRecoveryService start= demand
 
 sc config OracleServiceXE start= demand
 
 sc config OracleServiceXE start= demand
 
 sc config OracleXEClrAgent start= demand
 
 sc config OracleXETNSListener start= demand
 
 echo 成功切换为手动模式!
 
 goto oraclexe
 
 rem Teamviewer服务开启、关闭
 
 :teamviewer
 
 echo 1.开启Teamviewer服务，2.关闭Teamviewer服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto teamviewerstart
 
 if "%in%"=="2" goto teamviewerstop
 
 if "%in%"=="3" goto teamviewersd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose
 
 :teamviewerstart
 
 echo "正在启动Teamviewer相关开机服务..."
 
 net start TeamViewer7
 
 echo 服务启动完毕！
 
 goto teamviewer
 
 :teamviewerstop
 
 echo "正在关闭Teamviewer相关开机服务..."
 
 net stop TeamViewer7
 
 echo 服务已关闭！
 
 goto teamviewer
 
 :teamviewersd
 
 echo "切换TeamViewer开机启动服务为手动中,请稍候..."
 
 sc config TeamViewer7 start= demand
 
 echo 成功切换为手动模式！
 
 goto teamviewer
 
 rem alipay服务开启、关闭
 
 :alipay
 
 echo 1.开启alipay服务，2.关闭alipay服务。3.设置为手动。
 
 echo u.回到上层。e.退出。
 
 set in= 
 
 set /p in=请输入：
 
 if "%in%"=="1" goto alipaystart
 
 if "%in%"=="2" goto alipaystop
 
 if "%in%"=="3" goto alipaysd
 
 if "%in%"=="u" goto allstart
 
 if "%in%"=="e" goto allclose
 
 :alipaystart
 
 net start AliveSvc
 
 net start AlipaySecSvc
 
 goto alipay
 
 :alipaystop
 
 net stop AliveSvc
 
 net stop AlipaySecSvc
 
 goto alipay
 
 :alipaysd
 
 sc config AliveSvc start= demand
 
 sc config AlipaySecSvc start= demand
 
 goto alipay
 
 :allclose
 
 echo 按任意键退出
 
 pause
 
 exit