精华内容
下载资源
问答
  • Java中停止线程执行的方法

    万次阅读 2015-06-27 15:51:29
    Java中停止线程执行的方法作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、暂停或停止...或许有人会问,为什么不使用等待wait()或通知notify()?要知道,使用等待或通知都不是很好的方式。 线程可

    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修饰之后,那么它就具备了两层语义:

    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中停止线程执行的方法总结

    千次阅读 2015-11-12 22:15:34
    如何停止java的线程一直是开发多线程程序的一个非常头痛的问题,本文我们就来讨论一下关于Java中停止线程执行的方法,我们应该如何正确停止java中的线程。 Java中停止线程执行的方法 一、暂停或停止线程的...

    如何停止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
         }
    }

    展开全文
  • 在animate执行时如何停止

    千次阅读 2017-10-16 13:38:40
    就是倘若该元素就较多的动作,有好多个animate,那么stopAll的意思就是所有的animate直接停止,而goToEnd的意思就是当前的这个animate先结束,然后再停止。 注:goToEnd 只能在设置了 stopAll 参数时使用。

    写一个效果为点击后跳出一个弹框,在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)或...所以我们就通过“管理工具”中的“服务”将所有不必要的服务停止。但是每次用到的时候或不用的时候手工去启动和停止比较麻烦。用批理来操作会方便很多。 下面介

    当电脑安装了数据库服务(如,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

    展开全文
  • 解决slideToggle动画重复不停止

    千次阅读 2017-11-03 15:21:38
    方法:stop()。 .stop 是jQuery中用于控制页面动画效果的方法。运行之后立刻结束当前页面上的动画效果。 stop在新版jQuery中添加了2个...第二个参数是是否将当前动画效果执行到最后,意思就是停止当前动画的时候动画
  • ScheduledThreadPoolExecutor执行停止问题&Android几个动画回调运行线程
  • 最近在进行数据迁移的任务(就是迁移历史数据),数据量很大,需要运行几个月才能运行完。要求是每天的非工作时间定时进行迁移,...通过在网上搜查资料发现了停止执行任务的代码如下: public static void removeJob
  • shell中exit 1是什么意思

    千次阅读 2020-05-15 17:43:21
    比如,脚本里退出时是执行的exit 1,这次脚本停止执行并退出,退出后,在shell里echo $?,会得到1这个值。一般来说,0代表成功,其它值代表失败,具体什么值代表什么错误就看写脚本时的约定了。注意一点,$?
  • mysql刚启动就停止什么原因

    千次阅读 2018-07-17 09:57:00
    1、找到mysql安装目录,将其配置文件my....3、接下来,在命令行执行命令:mysqld --initialize --user=mysql --console4、注意,上一个步骤会获得一个临时密码,需要记录,之后会用到。5、接下来在控制台以命令行输...
  • 系统维护的时候难免会遇到进程的状态的查询和管理,到底什么是R,有的是S,有的还是S+呢?一直有些混沌的问题,今天细细的来总结一下: &nbsp;&nbsp; PS是用来报告系统中程序执行状况的命令这个是无可厚非的...
  • 系统错误null是什么意思 Java中NULL用法的简单示例: public Employee getByName(String name) { int id = database.find(name); if (id == 0) { return null; } return new Employee(id); } 这种方法有什么...
  • 最近电脑在关机时,总会出现这个提示,需要你强制关机 可以这么处理一下: win+R 召唤“运行”对话窗口,输入regedit 召唤注册表编辑器在如下路径计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\Current...
  • Python中+=是什么意思

    万次阅读 多人点赞 2014-03-19 09:51:25
    在while loops里我们常常会碰到的 += 意思很简单,大致上大家都说了再加以解释吧!>>> num = 1 当 num 小过5 或等于 5 它... num +=1在这儿的意思是 num = num + 1在while里面我们必须输入这一行代码,为什么...
  • 当初如易我也是初学者,随便从网上搜了一下,就转过来了,不过为了避免搜索结果同质化,为大家提供更翔实的参考,我将nohup.out相关知识整理汇总如下:1.nohup.out的由来及作用用途:LINUX命令用法,挂断地运行...
  • Keepalived监测脚本一直不执行

    千次阅读 2020-05-22 11:48:07
    Keepalived检查脚本一直不执行 今天在搭建Nginx+Keepalived集群时,启动Keepalievd发现检查脚本不执行,脚本本身是没有问题的。 1.1 监测脚本 脚本如下: A=`ps -C nginx --no-header |wc -l` if [ $A -eq 0 ];...
  • 安全点和安全区域是什么意思

    千次阅读 热门讨论 2021-05-17 23:51:49
    在 Java 虚拟机里,传统的垃圾回收算法为了枚举 GC Roots,必须要经历一个Stop-the-world(STW)的过程,即停止其他非垃圾回收线程的工作,直到完成垃圾回收。 Java 虚拟机中的 STW 是通过安全点(safepoint)机制来...
  • 一、什么是Shell?  shell是外壳的意思,就是操作系统的外壳。我们可以通过shell命令来操作和控制操作系统,比如Linux中的Shell命令就包括ls、cd、pwd等等。总结来说,Shell是一个命令解释器,它通过接受用户输入...
  • C语言里程序编译无误但运行会弹出程序已停止运行是为什么?原文链接(https://zhidao.baidu.com/question/1178139670043658699.html) 摘要 1. 内存溢出 内存溢出(out of memory)通俗理解就是内存不够,程序...
  • 输出的信息是什么意思? top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。下面详细介绍它的使用方法。 top - 01:06:48 up 1:22, 1 user, load ...
  • On Error Resume Next是什么意思

    千次阅读 2005-07-08 12:00:00
    On Error Resume Next的意思是如果发生错误就继续直接执行出错语句下面的那句。一般的,如果出错,VB会报告并停止运行,但有时错误并严重,不会产生严重影响,你可以在可能出错的语句前面加上这句。但是如果错误很...
  • @echo off 是什么意思

    万次阅读 2011-04-06 21:38:00
    @pause       -------------------------------- @echo off 是什么意思 就是说关闭回显 <br /> @echo off并是DOS程序中的, 而是DOS批处理中的。 当年的DOS...
  • /norestart 是重启的意思 /forcerestart 是强制重启 如果想批处理运行一系列的exe文件,均可以这么做 适合用在批量运行一系列exe文件时,如批量安装,安装补丁包 上面有一个问题就是会按顺序一个一个执行,...
  • Service的onUnbind方法不执行的问题

    千次阅读 2018-01-17 15:15:11
    client在SDK,Service在Server APP(以下Server和Service意思相同,均指的是Server APP),并且Server APP某一时刻只允许与一个APP进行通讯,即:应用A通过bindService连接上Server APP之后,Server APP会认为只有...
  • 指针赋值为NULL;是什么意思呢?

    万次阅读 多人点赞 2014-04-02 09:41:43
    这个NULL是什么意思?  网上百度了下,有人说NULL=0;是在头文件中定义的;  首先要说的是:非堆分配的内存是需要free的。  再说p=NULL;指针的变化是 p指向了一个地址为0的内存,这就提醒别人不要对这个...
  • verilog语言中的@什么意思 verilog语言中的@...verilog中@ 的含义就是触发条件的意思,举个例子,always 语言加入加@ 的话,就是一个一直执行的语句常用的是 always #10 clk=~clk;这是测试文件中常用的语句,这个
  • 这句话是什么意思什么时候跳出循环? 一、先对i的值进行判断 如果i的值0就退出 二、计算:i=i-1 再重复操作! i--表示先使用i,再让i=i-1。 假设初始i=3。第一次while()里的是3,while(3)=&gt;此时i=2(i--...
  • 有时候我们并想不断地执行一个函数,我们只希望在20秒后执行一个函数,然后就不执行了。比如,我们用微波炉烤西红柿,3分钟之后要叮地响一下,但是只要响一下就好了,不要每隔3分钟都响,那太烦人了! (小若:...
  • jenkins执行脚本退出

    千次阅读 2018-09-05 14:25:30
    意思是:因为你是从一个非tty环境执行脚本;Jenkins能正常从你的脚本中退出。 解决办法: 外国网友解释: Since you are executing a script from a non-TTY environment; The Jenkins is not able to get the ...
  • 在linux的top命令里的cpu信息是什么意思呢? Cpu(s): 62.1% us, 15.9% sy, 0.1% ni, 19.4% id, 2.0% wa, 0.1% hi, 0.4% si Mem: 8247956k total, 8232004k used, 15952k free, 205240k buffers Swap: 8191

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 152,727
精华内容 61,090
关键字:

不停止执行是什么意思