精华内容
下载资源
问答
  • 请问:用java代码怎么运行,停止,重启memcached?谢谢!
  • 写了一个方法。是一个server端。因为在后台写的代码所以需要用代码来停止怎么写。。。
  • 好吧,虽然这是一个老套的问题,我是新手,新写了一个网络版坦克大战,server端占用了没有写窗口也没有创建什么条件退出的语句,然后打包成了一个jar包,点击运行,然后不知道怎么停了,求帮助
  • 其实这就是SpringBoot项目运行一段时间停止运行java -jar项目运行一段时间停止、java程序运行一段时间自动关闭 的问题了。 解决方案 用java -jar xxxx-web-0.0.1-SNAPSHOT.jar >xxxx.log&amp...

    问题背景

    手头有一个springboot项目,放在测试服务器跑,但是隔三差五的,就会中断,很好奇到底怎么回事。

    其实这就是SpringBoot项目运行一段时间停止运行java -jar项目运行一段时间停止java程序运行一段时间自动关闭 的问题了。

    解决方案

    java -jar xxxx-web-0.0.1-SNAPSHOT.jar >xxxx.log&
    启动后项目看似脱离终端了,其实还是受终端影响,断开xshell之后,项目过段时间就会挂了。GG。

    把启动语句加上nohup后台运行就可以了。

    nohup+java命令示范:

    #docker
        nohup docker-compose up > /usr/local/logs/microservice-tcbj-yytsg/log.txt &
    
    #springboot
        nohup java -jar microservice-web-0.0.1-SNAPSHOT.jar >microservice.log&

    nohup是什么

    用途:nohup是linux一个命令,不挂断地运行,或者理解为后台运行。

    语法:nohup Command [ Arg … ] [ & ]

      无论是否将 nohup 命令的输出重定向到终端,输出都将附加到当前目录的 nohup.out 文件中。

      如果当前目录的 nohup.out 文件不可写,输出重定向到 $HOME/nohup.out 文件中。

      如果没有文件能创建或打开以用于追加,那么 Command 参数指定的命令不可调用。

    退出状态:该命令返回下列出口值:   
      126 可以查找但不能调用 Command 参数指定的命令。   
      127 nohup 命令发生错误或不能查找由 Command 参数指定的命令。   
      否则,nohup 命令的退出状态是 Command 参数指定命令的退出状态。

    展开全文
  • java编写的猜数小程序一执行就出现停止运行 这是怎么回事????
  • 我想能够同步实现这几个方法),然后点击ON按钮就开始运行服务器程序了, **重点来了** , **我现在的问题是** ,停止按钮OFF不知道怎么设置方法能够让程序停止当前的线程,我想实现的是点击OFF后,当前的监控方式...
  • 大佬们,虚拟机运行软件停止运行,求解决。 这是activity_main.xml xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" ...
  • 其实这就是SpringBoot项目运行一段时间停止运行java -jar项目运行一段时间停止、java程序运行一段时间自动关闭 的问题了。 解决方案 用java -jar xxx-service-0.0.1-SNAPSHOT.jar >xxxx.log& 原来项目启动...

    nohup命令解决SpringBoot/java -jar命令启动项目运行一段时间自动停止问题

    只要终端关了 服务就会停止。
    把启动语句加上nohup后台运行就可以了。

    nohup+java命令示范:

    nohup java -jar uyang_wx-0.0.1-SNAPSHOT.jar > a1.log 2>&1 &
    
    nohup java -jar (自己的jar包名称) > a1.log 2>&1 &
    
    用java -jar xxx-service-0.0.1-SNAPSHOT.jar >xxxx.log&
    

    查看端口是否被占用

    netstat -anp | grep 80
    

    查看被占用端口的PID

    sudo lsof -i:80
    

    杀死占用端口进程

    sudo kill -9 10364
    
    展开全文
  • 正确停止的方法 interrupt 通常线程会在什么情况下停止 在线程运行时如何阻塞线程 public class RightWayStopThreadWithoutSleep implements Runnable { //正常运行状态下的中断线程法 @Override public...

    正确停止的方法 interrupt

    通常线程会在什么情况下停止。

    在线程运行时如何阻塞线程

    public class RightWayStopThreadWithoutSleep implements Runnable {
    
    //正常运行状态下的中断线程法
    
        @Override
        public void run() {
            int num = 0;
            //这里加了 判断 如果外部 执行了中断 会有一个标记位设置true
            //这样的话 是通过在线程内部添加 检查来判断的 
            while(!Thread.currentThread().isInterrupted()  &&num <= Integer.MAX_VALUE /2 ){
                if(num % 10000 == 0 ){
                    System.out.println(num + "是100000万的倍数");
                }
                num ++;
            }
            System.out.println("任务运行结束了");
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopThreadWithoutSleep());
            //开启一个线程
            thread.start();
            //等待2秒后
            thread.sleep(2000);
            //线程中断请求 我们提出了但断不断 看线程心情
            thread.interrupt();
        }
    }
    

    直接调用线程的 interrupt(); 线程 不会自己停止 原因是线程有权按照自己的实际情况来自行决定什么时候该中断。
    所以通过 在线程内部 方法中 手动添加 Thread.currentThread().isInterrupted() 判断当前线程有没有 被设置了中断来处理。

    睡眠状态下线程的阻断

    package stopThread;
    
    import org.omg.PortableServer.THREAD_POLICY_ID;
    
    public class RightStopThreadwithSleep {
        /**
         *  带有sleep的中断线程的写法
         * @param args
         */
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable =() ->{
                int num = 0;
                //以下这句判断 外部是否对线程 中断 其实不需要 原因如 1.
                while(num <= 300 && !Thread.currentThread().isInterrupted()){
                    if(num %100 == 0){
                        System.out.println(num + "是100的倍速");
                    }
                    num ++;
                }
                try {
                    //1.休眠1秒 休眠状态下 其实程序会自动响应中断请求
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
            //休眠 500毫秒
            Thread.sleep(500);
            //会报错 睡眠时中断 标志位清空
            thread.interrupt();
        }
    }
    

    在线程运行过后500毫秒 执行中断 但是 此时线程内执行了完成后 会休眠一秒 此时中断 的话 就会导致线程内中断倍打断 并抛出异常:
    在这里插入图片描述

    在这里插入图片描述
    所以最好在 sleep() 做异常处理。

    如果再循环中会有休眠状态 这时中断会自动响应

    package stopThread;
    
    import org.omg.PortableServer.THREAD_POLICY_ID;
    
    public class RightStopThreadwithSleep {
        /**
         *  带有sleep的中断线程的写法
         * @param args
         */
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable =() ->{
    
                int num = 0;
                try {
                while(num <= 1000000){
                    //这部分执行耗费很低
                    if(num %100 == 0){
                        System.out.println(num + "是100的倍速");
                    }
                    num ++;
                    //整个方法 大部分运行时间消耗在 睡眠中
                    Thread.sleep(20);
                }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
    
            };
            Thread thread = new Thread(runnable);
            thread.start();
            //休眠 500毫秒
            Thread.sleep(1000);
            //中断
            thread.interrupt();
        }
    }
    

    在休眠的过程中 不需要在代码中 去判断是否需要响应外部的中断 java会有自己中断的机制自动响应中断。

    改变try catch 导致中断无法实现(错误)

    package stopThread;
    
    public class CannetInterupt {
    
        public static void main(String[] args) throws InterruptedException {
            Runnable runnable =() ->{
    
                int num = 0;
                    //由于 1的原因 导致中断没法响应 在while 判断 加上isInterrupted() 来判断是否被外部中断了
                    //3. 上面是想的是理想情况 由于 2. 的原因导致 其实标志位 已经被清除了 也就没法判断了 所以加上判断也无济于事
                    while(num <= 1000000 && !Thread.currentThread().isInterrupted()){
                        //这部分执行耗费很低
                        if(num %100 == 0){
                            System.out.println(num + "是100的倍速");
                        }
                        num ++;
                        //1.改变 catch 位置 导致错误倍catch住了 就没满足while 跳出的条件  就继续执行下一次循环了
                        try {
                        Thread.sleep(20);
                        //2.一旦程序响应了中断 中断标记位就会被清除
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
    
    
            };
            Thread thread = new Thread(runnable);
            thread.start();
            //休眠 500毫秒
            Thread.sleep(1000);
            //中断
            thread.interrupt();
        }
        }
    
    
    
    
    
    

    在这里插入图片描述

    由于改变了 try-catch 的位置 而导致无法响应中断。

    以上是一些中断的基本方法 有好有坏。但在实际开发中又该怎么中断呢?

    1. 优先选择:传递中断
    2. 不想或无法传递: 恢复中断
    3. 不应屏蔽中断

    ❌示例

    package stopThread;
    
    /**
     * DESC:最佳实践 在方法签名中抛出异常
     * run() 强制就会 try/catch
     */
    
    public class RightWayStopInProd  implements Runnable{
    
    
        @Override
        public void run() {
        while(true){
            System.out.println("go");
            throwInMethod();
        }
        }
    
        private void throwInMethod() {
        try{
                Thread.sleep(100);
        } catch (InterruptedException e) {
        	//?这里已经处理了错误 人家帮你处理了 你都还不知道怎么处理好的错误。不太好
            e.printStackTrace();
        }
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopInProd());
            thread.start();
            thread.sleep(1000);
            thread.interrupt();
        }
    }
    
    

    在这里插入图片描述
    解释下第一点 看上面的实例 程序报错了却还在一直运行 因为在底层 已经处理了错误 上面的方法去调用的时候完全是没法处理的 这样子问题就来了 当你调用别人的写代码库的时候 有些错误 你都没做法做出自己的处理方法 要么你就把他代码修改修改 处理你这个错误 但这样真的好吗 ?

    正确抛出异常

    package stopThread;
    
    public class RunThrowException implements Runnable {
    
    
        @Override
        public void run() {
            while(true && !Thread.currentThread().isInterrupted()){
                System.out.println("go");
                System.out.println(Thread.currentThread().getName());
                try {
                    throwInMethod();
                } catch (InterruptedException e) {
                    System.out.println("打印异常日志");
    
                }
            }
        }
    
        private void throwInMethod() throws InterruptedException {
                //直接抛出异常
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName());
    
    
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RunThrowException());
            thread.start();
            thread.sleep(1000);
            thread.interrupt();
        }
    }
    
    

    一般异常要抛出到顶层人员处理,因为我们不知道调用的人的业务逻辑所以不能擅自帮助别人就处理了错误。

    当我们无法不想抛出异常时

    package stopThread;
    
    /**
     * DESC:最佳实践 在catch自语句中调用Thread
     * currentThread.interrupt()来恢复设置中断状态,一遍于在后续的执行中,依然能够检查到刚才发生的中断
     * 回到刚才 RightWayStopInProd2 不上中断 跳出
     */
    
    public class RightWayStopInProd2 implements Runnable{
    
    
        @Override
        public void run() {
        while(true ){
            //当程序感知到异常退出
            if(Thread.currentThread().isInterrupted()){
                System.out.println("go");
                break;
    
            }
            throwInMethod();
        }
        }
    
        private void throwInMethod() {
        try{
                Thread.sleep(100);
        } catch (InterruptedException e) {
            //当中断 被触发 且被catch住 那就 没办法响应了 那怎么办呢
            //重新 设置下 刚才被清除的中断
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new RightWayStopInProd2());
            thread.start();
            thread.sleep(1000);
            thread.interrupt();
        }
    }
    
    

    当catch住 中断后 中断标记会消失 顶层就没法处理这个错误 解决方法 在把Thread.currentThread().interrupt();中断恢复。

    其他停止方法

    错误的停止方法 Stop (弃用)

    package stopThread;
    
    public class StopThread implements Runnable {
        @Override
        public void run() {
            //模拟订单生成 到出库的一个过程 关键是这个过程是原子性的不可以被打断
            for (int i = 0;i<5;i++){
                System.out.println("订单" + i +"开始创建");
    
            for (int j = 0;j<4;j++){
                if(j == 0)
                System.out.println("订单" + i +":订单生成");
                else if(j == 1)
                System.out.println("订单" + i +":订单扣减库存");
                else if (j == 2)
                System.out.println("订单" +i +":订单付费成功");
                else if (j == 3)
                    System.out.println("订单" +i +":订单自动分配仓库");
                else if (j == 4)
                    System.out.println("订单" +i +":订单自动出库");
    
                try{
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("订单" + i + ":完成");
            }
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread a = new Thread(new StopThread());
            a.start();
            Thread.sleep(1000);
           	a.stop();
    
    
        }
    }
    
    
    

    在这里插入图片描述

    假设有一个方法是 处理 订单生成到发货的 如果使用 stop()去中断 程序会 戛然而止 这样就没法 完整的处理完一个流程了 这是个很严重的问题 如果在处理某些问题的时候 突然被中断 导致订单数据 出现错乱。

    暂停线程Suspend (弃用)

    容易造成死锁 当他挂起的时候 会带着锁 如果其他线程没有及时把它唤醒 或者唤醒它的线程需要它这把索就会形成死锁。

    Volatitle的标记位

    使用Volatitle来终止线程

    package stopThread.volatiledemo;
    
    /**
     *  描述: 演示用volatitle的局限
     */
    public class WrowngWayVolatitle implements Runnable {
        private volatile boolean canceled =false;
    
    
        @Override
        public void run() {
            int num = 0;
            try {
                //判断标志位 在程序内部 终止
                while (num <= 10000 && !canceled) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数");
                    }
                    num++;
                    Thread.sleep(1);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
    
        }
    
        public static void main(String[] args) throws InterruptedException {
            WrowngWayVolatitle wr = new WrowngWayVolatitle();
            Thread a =  new Thread(wr);
            a.start();
            a.sleep(5000);
            //通过设置标志位 来实现 程序的停止
            wr.canceled =true;
    
        }
    }
    
    

    在以下情况 假设有一个生产者 一个消费者 当消费者 在消费时停止线程 这时候就没法用 volatitle

    package stopThread.volatiledemo;
    
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    
    /**
     *  演示volatitle的局限
     *  陷入阻塞式,volatitle是无法实现的
     *  此例中 生产者的生产速度很快 消费者速度慢 所以阻塞队列满了以后 生产者会阻塞 ,等待消费者进一步消费
     */
    
    public class WorngWayVolatitleCannotStop {
        public static void main(String[] args) throws InterruptedException {
            ArrayBlockingQueue storge = new ArrayBlockingQueue(10);
            Producer producer  = new Producer(storge);
            Thread thread = new Thread(producer);
            thread.start();
            Thread.sleep(1000);
            Consumer c1 = new Consumer(storge);
            while(c1.needMoreNums()){
    
                System.out.println(c1.storage.take()+"被消费了");
                Thread.sleep(100);
            }
            System.out.println("不需要消费了");
            producer.canceled =true;
            System.out.println(producer.canceled);
    
    
        }
    
    
        }
    
    class Producer implements Runnable {
        public volatile boolean canceled =false;
        BlockingQueue storage;
    
        public Producer(BlockingQueue storage) {
            this.storage = storage;
        }
        @Override
        public void run() {
            int num = 0;
            try {
                while (num <= 100000 && !canceled) {
                    if (num % 100 == 0) {
                        System.out.println(num + "是100的倍数放到仓库里" );
                        this.storage.put(num);
                    }
                    num++;
                    //Thread.sleep(1);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                System.out.println("结束运行");
            }
    
        }
    }
    //消费者
     class Consumer {
        BlockingQueue storage;
    
        public Consumer(BlockingQueue storage) {
            this.storage = storage;
        }
    
        public boolean needMoreNums() {
            if (Math.random() > 0.95) {
                return false;
            }
            return true;
        }
    }
    
    展开全文
  • 有一个java方法正在运行中,可能多个用户在调用这个方法,现在有一个用户同时调用了两次这个方法,第一次的调用仍然在执行中,有什么方法可关闭这个用户的第一次调用,同时不影响其他...
  • 不知道是怎么回事, TERM trapped. Shutting down. STATUS | wrapper | 2011/03/17 18:08:50 | STATUS | wrapper | 2011/03/17 18:09:01 | --> Wrapper Started as Daemon STATUS | wrapper | 2011/03/17 18:...
  • 背景中断(Interrupt)一个线程意味着在该线程完成任务之前停止其正在进行的一切,有效地中止其当前的操作。线程是死亡、还是等待新的...虽然它确实停止了一个正在运行的线程,然而,这种方法是不安全也是不受提倡的...

    背景中断(Interrupt)一个线程意味着在该线程完成任务之前停止其正在进行的一切,有效地中止其当前的操作。线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序。虽然初次看来它可能显得简单,但是,你必须进行一些预警以实现期望的结果。你最好还是牢记以下的几点告诫。

        首先,忘掉Thread.stop方法。虽然它确实停止了一个正在运行的线程,然而,这种方法是不安全也是不受提倡的,这意味着,在未来的JAVA版本中,它将不复存在。

        一些轻率的家伙可能被另一种方法Thread.interrupt所迷惑。尽管,其名称似乎在暗示着什么,然而,这种方法并不会中断一个正在运行的线程(待会将进一步说明),正如Listing A中描述的那样。它创建了一个线程,并且试图使用Thread.interrupt方法停止该线程。 Thread.sleep()方法的调用,为线程的初始化和中止提供了充裕的时间。线程本身并不参与任何有用的操作。

    class Example1 extends Thread {
                boolean stop=false;
                public static void main( String args[] ) throws Exception {
                Example1 thread = new Example1();
                System.out.println( "Starting thread..." );
                thread.start();
                Thread.sleep( 3000 );
                System.out.println( "Interrupting thread..." );
                thread.interrupt();
                Thread.sleep( 3000 );
                System.out.println("Stopping application..." );
                //System.exit(0);
                }
                public void run() {
                while(!stop){
                System.out.println( "Thread is running..." );
                long time = System.currentTimeMillis();
                while((System.currentTimeMillis()-time < 1000)) {
                }
                }
                System.out.println("Thread exiting under request..." );
                }
                }

        如果你运行了Listing A中的代码,你将在控制台看到以下输出:

    Starting thread...
    Thread is running...
    Thread is running...
    Thread is running...
    Interrupting thread...
    Thread is running...
    Thread is running...
    Thread is running...
    Stopping application...
    Thread is running...
    Thread is running...
    Thread is running...
    ...............................

        甚至,在Thread.interrupt()被调用后,线程仍然继续运行。

        真正地中断一个线程

        中断线程最好的,最受推荐的方式是,使用共享变量(shared variable)发出信号,告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量(尤其在冗余操作期间),然后有秩序地中止任务。Listing B描述了这一方式。

    Listing B
    class Example2 extends Thread {
      volatile boolean stop = false;
      public static void main( String args[] ) throws Exception {
        Example2 thread = new Example2();
       System.out.println( "Starting thread..." );
       thread.start();
       Thread.sleep( 3000 );
       System.out.println( "Asking thread to stop..." );
       thread.stop = true;
       Thread.sleep( 3000 );
       System.out.println( "Stopping application..." );
       //System.exit( 0 );
      }
      public void run() {
        while ( !stop ) {
         System.out.println( "Thread is running..." );
          long time = System.currentTimeMillis();
          while ( (System.currentTimeMillis()-time < 1000) && (!stop) ) {
          }
        }
       System.out.println( "Thread exiting under request..." );
      }
    }

        运行Listing B中的代码将产生如下输出(注意线程是如何有秩序的退出的)

    Starting thread...
    Thread is running...
    Thread is running...
    Thread is running...
    Asking thread to stop...
    Thread exiting under request...
    Stopping application...

        虽然该方法要求一些编码,但并不难实现。同时,它给予线程机会进行必要的清理工作,这在任何一个多线程应用程序中都是绝对需要的。请确认将共享变量定义成volatile 类型或将对它的一切访问封入同步的块/方法(synchronized blocks/methods)中。

        到目前为止一切顺利!但是,当线程等待某些事件发生而被阻塞,又会发生什么?当然,如果线程被阻塞,它便不能核查共享变量,也就不能停止。这在许多情况下会发生,例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时,这里仅举出一些。

        他们都可能永久的阻塞线程。即使发生超时,在超时期满之前持续等待也是不可行和不适当的,所以,要使用某种机制使得线程更早地退出被阻塞的状态。

        很不幸运,不存在这样一种机制对所有的情况都适用,但是,根据情况不同却可以使用特定的技术。在下面的环节,我将解答一下最普遍的例子。

        使用Thread.interrupt()中断线程

        正如Listing A中所描述的,Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是,在线程受到阻塞时抛出一个中断信号,这样线程就得以退出阻塞的状态。更确切的说,如果线程被Object.wait, Thread.join和 Thread.sleep三种方法之一阻塞,那么,它将接收到一个中断异常(InterruptedException),从而提早地终结被阻塞状态。

        因此,如果线程被上述几种方法阻塞,正确的停止线程方式是设置共享变量,并调用interrupt()(注意变量应该先设置)。如果线程没有被阻塞,这时调用interrupt()将不起作用;否则,线程就将得到异常(该线程必须事先预备好处理此状况),接着逃离阻塞状态。在任何一种情况中,最后线程都将检查共享变量然后再停止。Listing C这个示例描述了该技术。

    Listing C
    class Example3 extends Thread {
      volatile boolean stop = false;
      public static void main( String args[] ) throws Exception {
       Example3 thread = new Example3();
       System.out.println( "Starting thread..." );
       thread.start();
       Thread.sleep( 3000 );
       System.out.println( "Asking thread to stop..." );
       thread.stop = true;//如果线程阻塞,将不会检查此变量
       thread.interrupt();
       Thread.sleep( 3000 );
       System.out.println( "Stopping application..." );
       //System.exit( 0 );
      }
      public void run() {
        while ( !stop ) {
         System.out.println( "Thread running..." );
          try {
          Thread.sleep( 1000 );
          } catch ( InterruptedException e ) {
          System.out.println( "Thread interrupted..." );
          }
        }
       System.out.println( "Thread exiting under request..." );
      }
    }

        一旦Listing C中的Thread.interrupt()被调用,线程便收到一个异常,于是逃离了阻塞状态并确定应该停止。运行以上代码将得到下面的输出:

    Starting thread...
    Thread running...
    Thread running...
    Thread running...
    Asking thread to stop...
    Thread interrupted...
    Thread exiting under request...
    Stopping application...

    中断I/O操作

        然而,如果线程在I/O操作进行时被阻塞,又会如何?I/O操作可以阻塞线程一段相当长的时间,特别是牵扯到网络应用时。例如,服务器可能需要等待一个请求(request),又或者,一个网络应用程序可能要等待远端主机的响应。

        如果你正使用通道(channels)(这是在Java 1.4中引入的新的I/O API),那么被阻塞的线程将收到一个 ClosedByInterruptException异常。如果情况是这样,其代码的逻辑和第三个例子中的是一样的,只是异常不同而已。

        但是,你可能正使用Java1.0之前就存在的传统的I/O,而且要求更多的工作。既然这样,Thread.interrupt()将不起作用,因为线程将不会退出被阻塞状态。Listing D描述了这一行为。尽管interrupt()被调用,线程也不会退出被阻塞状态。

    Listing D
    import java.io.*;
    class Example4 extends Thread {
      public static void main( String args[] ) throws Exception {
        Example4 thread = new Example4();
       System.out.println( "Starting thread..." );
       thread.start();
       Thread.sleep( 3000 );
       System.out.println( "Interrupting thread..." );
       thread.interrupt();
       Thread.sleep( 3000 );
       System.out.println( "Stopping application..." );
       //System.exit( 0 );
      }
      public void run() {
       ServerSocket socket;
        try {
          socket = new ServerSocket(7856);
        } catch ( IOException e ) {
         System.out.println( "Could not create the socket..." );
          return;
        }
        while ( true ) {
         System.out.println( "Waiting for connection..." );
          try {
           Socket sock = socket.accept();
          } catch ( IOException e ) {
          System.out.println( "accept() failed or interrupted..." );
          }
        }
      }
    }

        很幸运,Java平台为这种情形提供了一项解决方案,即调用阻塞该线程的套接字的close()方法。在这种情形下,如果线程被I/O操作阻塞,该线程将接收到一个SocketException异常,这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似。

        唯一要说明的是,必须存在socket的引用(reference),只有这样close()方法才能被调用。这意味着socket对象必须被共享。Listing E描述了这一情形。运行逻辑和以前的示例是相同的。

    Listing E
    import java.net.*;
    import java.io.*;
    class Example5 extends Thread {
      volatile boolean stop = false;
      volatile ServerSocket socket;
      public static void main( String args[] ) throws Exception {
        Example5 thread = new Example5();
       System.out.println( "Starting thread..." );
       thread.start();
       Thread.sleep( 3000 );
       System.out.println( "Asking thread to stop..." );
       thread.stop = true;
       thread.socket.close();
       Thread.sleep( 3000 );
       System.out.println( "Stopping application..." );
       //System.exit( 0 );
      }
      public void run() {
        try {
          socket = new ServerSocket(7856);
        } catch ( IOException e ) {
         System.out.println( "Could not create the socket..." );
          return;
        }
        while ( !stop ) {
         System.out.println( "Waiting for connection..." );
          try {
           Socket sock = socket.accept();
          } catch ( IOException e ) {
          System.out.println( "accept() failed or interrupted..." );
          }
        }
       System.out.println( "Thread exiting under request..." );
      }
    }

        以下是运行Listing E中代码后的输出:

    Starting thread...
    Waiting for connection...
    Asking thread to stop...
    accept() failed or interrupted...
    Thread exiting under request...
    Stopping application...

        多线程是一个强大的工具,然而它正呈现出一系列难题。其中之一是如何中断一个正在运行的线程。如果恰当地实现,使用上述技术中断线程将比使用Java平台上已经提供的内嵌操作更为简单。

    展开全文
  • at java.lang.reflect.Method.invoke(Method.java:515) at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:780) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:596...
  • 背景中断(Interrupt)一个线程意味着在该线程完成任务之前停止其正在进行的一切,有效地中止其当前的操作。线程是死亡、还是等待新的...虽然它确实停止了一个正在运行的线程,然而,这种方法是不安全也是不受提...
  • 停止 //如不能运行,请正确配置tomcat环境 public class conTomCat{ public void close() throws IOException { Process process = Runtime.getRuntime().exec('cmd /c D:\\apache-tomcat-7.0.16\\bin\\shutdown.bat...
  • 如何在Android Studio中完成之前停止运行方法我有一个模式与计时器和关闭按钮。当定时器结束时,模式将关闭,或在关闭按钮结束计时器之前关闭模式。这里的图片: 但是,当我手动关闭模式与按关门按钮,运行计时器仍...
  • Java基础之停止线程

    2020-09-03 23:33:15
    停止线程: 1,stop方法。 2,run方法结束。 怎么控制线程的任务结束呢? 任务中都会有循环结构,只要控制住循环就可以结束任务。 控制循环通常就用定义标记来完成。 但是如果线程处于了冻结状态,无法读取标记。...
  • 大佬,可以问个问题吗》jar包在linux运行,可以在jar包进程停止前,进行扑捉吗?扑捉记录这个,然后再让其进程被杀掉吗?java应该怎么写,有相关的帖子链接指导吗
  • Java里如何安全的停止Thread ...既然我们不能使用stop方法停止运行中的线程,那怎么样才能安全的终止一个正在运行的线程呢? 答案就是使用自定义的标志位来判断线程的执行情况,话不多说,我们上代码: publ...
  • 昨天晚上使用ssh框架搭载学生管理系统时搭载UserAction类时运行tomcat出现了: 同时也在网上查询了很多关于这个的解决办法,但是都没有解决。 今天就为大家提供一个MyEclipse2017版本的解决办法 我原本的的JDK版本为...
  • # A fatal error has been detected by the Java Runtime Environment: # # EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000770232d0, pid=3320, tid=5676 # # JRE version: Java(TM) SE Runtime Envi...
  • 原以为是tomcat的问题,换了tomcat还会报错。 如图,错误信息是说dt_socket.dll文件有错。这个文件是在jdk文件夹中jre/bin下的。这么说还是jdk的问题? 这个错误什么时候产生不明确,只得等待。...
  • 注意:我们要知道暂停监听是要让某一段代码停止执行,而不不是去关闭线程,可以认为线程一旦关闭就只能下次运行时再开启 1. 创建一个“暂停按钮” JButton BuSwitch=new JButton("停"); this.add(BuSwitch); 2. ...
  • 需要些两个脚本 1.启动脚本 start.sh ...java -jar /opt/java/wechat-0.0.1-SNAPSHOT.jar > /opt/temp.txt & & 后台运行符号 将jar包启动对应的pid写入文件中,为停止时提供pid echo ...
  • MySQL 服务有时会自动停止,然后再运行 当它停止时 我的JAVA程序会报 com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure的错误 程序是一直反复读取数据库信息的,而当抛出这个...
  • Java怎么实现退出

    2013-05-14 05:25:34
    在VB中可以这样: Sub doitnow() dim a = 1 for a = 1 to 45 if a = 5 ...如何在Java中实现相同的退出?有一个项目,以多种方式进入,如果设置...但是同样的activity还是继续运行,并不能停止创建一个停止错误。
  • 问题描述我打好的jar包,放在服务器上之后,在windows里面用xshell打开一个连接,然后运行java -jar 。。。。执行这个jar文件,当我关闭这个链接的时候为什么程序停止了呢?打开XShell连接并运行java -jar XX.jar...
  • is never used,但是我运行程序后,控制台死活显示不出内容,但是停止键又是亮着的,Scanner sc=new Scanner(System.in)以下的语句,都无法显示,不知道怎么回事,第一次遇见,没有提示error,没有红色感叹号,有谁...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 160
精华内容 64
关键字:

java怎么停止运行

java 订阅