精华内容
下载资源
问答
  • 多线程中断机制

    万次阅读 热门讨论 2017-08-18 12:02:55
    在 java中启动线程非常容易,大多数情况下是让一个线程执行完自己的任务然后自己停掉... 在当前的api中,Thread.suspend、Thread.stop等方法都被Deprecated了,线程只能用interrupt中断,而且不是立刻中断,只是发了一

    友情推荐:

    1. 线程池原理
    2. 深入Thread.sleep
    3. head first Thread.join()

    在 java中启动线程非常容易,大多数情况下是让一个线程执行完自己的任务然后自己停掉。一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果,比如会带着自己所持有的锁而永远的休眠,迟迟不归还锁等。在当前的api中,Thread.suspend、Thread.stop等方法都被Deprecated了,线程只能用interrupt中断,而且不是立刻中断,只是发了一个类似于信号量的东西,通过修改了被调用线程的中断状态来告知那个线程, 说它被中断了,至于什么时候中断,这个有系统判断,会在一个合适的时候进行中断处理。

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            System.out.println("interrupt执行前");
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            nThread.interrupt();
            System.out.println("interrupt执行后");
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread{
            @Override
            public void run() {
                super.run();
                while(true){
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    这里写图片描述

    在上面代码中,线程睡醒之后,调用thread线程的interrupt方法,catch到InteruptedException,设置标志位。interrupt()方法相当于线程睡着的时候一盆凉水来吵醒它,线程表示不开心,并向你抛出一个大大的异常以示不满。

    这里写图片描述

    • 首先:线程中断是一种协作机制,调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时间中断自己。
    • 其次:任务的方法必须是可中断的,即方法必须抛出InterruptedException。

    由此可见,interrupt() 方法并不能立即中断线程,该方法仅仅告诉线程外部已经有中断请求,至于是否中断还取决于线程自己。在Thread类中除了interrupt() 方法还有另外两个非常相似的方法:interrupted 和 isInterrupted 方法,下面来对这几个方法进行说明:

    • interrupt 此方法是实例方法,用于告诉此线程外部有中断请求,并且将线程中的中断标记设置为true,而不是立即中断。
    • interrupted 此方法是类方法,用来判断当前线程是否已经中断。线程的中断状态由该方法清除。
    • isInterrupted 此方法是实例方法,用来判断线程是否已经中断。线程的中断状态不受该方法的影响。

    总结:java线程中断机制通过调用Thread.interrupt() 方法来做的,这个方法通过修改了被调用线程的中断状态来告知那个线程说它被中断了。对于非阻塞中的线程,只是改变了中断状态,即Thread.isInterrupted() 将返回true;对于可取消的阻塞状态中的线程,比如等待在这些函数上的线程,Thread.sleep()、Object.wait()、Thread.join(), 这个线程收到中断信号后,会抛出InterruptedException,同时会把中断状态置回为true。但调用Thread.interrupted()会对中断状态进行复位。

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("cancel执行前" + System.currentTimeMillis());
            nThread.cancel();
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread {
    
            private boolean isCancel;
    
            @Override
            public void run() {
                while (!isCancel) {
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("while结束" + System.currentTimeMillis());
            }
    
            public void cancel() {
                this.isCancel = true;
            }
        }
    }

    执行结果:

    依然存活...
    cancel执行前1502964413042
    while结束1502964415042

    机智的你,此刻一定发现执行前后相差2000毫秒,难道cancel()方法执行了2000毫秒?这纯属扯淡,里面没有任何耗时操作,就是一个赋值而已,其实是子线程的退出,前提条件是while循环结束,当且仅当cancel标示设置为true的瞬间立马执行while的判断,此时的时间差才可以忽略不计(1毫秒内),但是当我们调用cancel方法将isCancel 标记设置为true 时,while循环里面有一个耗时操作(休眠5000毫秒),只有等待耗时操作执行完毕后才会去检查这个标记,所以cancel方法和线程退出中间有时间间隔。

    接下来,我们通过interrupt 和 isinterrupt 方法来中断线程,代码如下:

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("interrupt执行前"+System.currentTimeMillis());
            nThread.interrupt();
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread{
    
            @Override
            public void run() {
                while(!interrupted()){
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        System.out.println("InterruptedException");
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("interrupt执行后"+System.currentTimeMillis());
            }
        }
    }
    
    依然存活...
    interrupt执行前1502965915683
    InterruptedException
    interrupt执行后1502965915683

    这次立马中断了,是因为在开启子线程后,经过执行3000毫秒的休眠,线程执行了interrupt 方法,此时子线程的5000毫秒休眠还没结束,就像上述所说的睡眠中被一盆冷水吵醒,很不开心的抛了异常,Thread.currentThread().interrupt() 改变了线程的标记状态,在抛出InterruptedException 的同时,线程的中断标志被清除了,再次执行while循环语句的时候,!interrupted() 此时是false,便不再执行while语句。

    此处如果去掉Thread.currentThread().interrupt() ,线程便会无休止的执行下去,此处就不上代码了,就注释掉这一行,运行就可以看到效果,经常看到一些代码在catch中不作任何处理,其实有时候这样是很危险的,此处已经证明。

    两点建议:
    1. 除非你知道线程的中断策略,否则不应该中断它。
    2. 任务代码不该猜测中断对执行线程的含义。遇到InterruptedException异常时,不应该将其捕获后“吞掉”,而应该继续向上层代码抛出。

    微信扫我,^_^

    SouthEast

    展开全文
  • java 多线程-02-线程中断 interrupt()

    万次阅读 2021-06-11 09:34:03
    线程中断 interrupt() 线程的Thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,完全取决于目标线程的自行决定。线程会...

    线程中断 interrupt()

    线程的Thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,完全取决于目标线程的自行决定。线程会不时地检测这个中断标志位,以判断线程是否应该被中断(中断标示值是否为true)。它并不像stop方法那样会强制的终止一个正在运行的线程。

    中断相关的方法

    public static boolean interrupted 测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false。
    public boolean isInterrupted() 测试线程是否已经中断。线程的中断状态 不受该方法的影响。
    public void interrupt() 中断线程

    如果一个线程收到中断的信息,但是没有处理中断的逻辑,将继续之前的运行而不受任何影响。

    引入sleep()方法

    public static native void sleep(long millis) throws InterruptedException;
    

    native标识的方法叫本地方法,该方法的功能是由额外的C++代码实现的,而这个C++代码其实就在电脑本地里

    sleep 会抛出InterruptedException异常,在案例中,在中断线程t1.interrupt()时,会被catch (InterruptedException e) 捕获。这时需要重新设置为中断状态Thread.currentThread().interrupt()。

    TimeUnit.SECONDS.sleep()

    对Thread.sleep方法的包装,实现是一样的,只是多了时间单位转换和验证,然而TimeUnit枚举成员的方法却提供更好的可读性

    public void sleep(long timeout) throws InterruptedException {
        if (timeout > 0) {
            long ms = toMillis(timeout);
            int ns = excessNanos(timeout, ms);
            Thread.sleep(ms, ns);
        }
    }
    

    案例:

    package com.Thread;
    
    import java.util.concurrent.TimeUnit;
    
    public class Thread_03_demo {
    
        public static void main(String[] args) {
    
    
            Thread t1 = new Thread("a"){
                @Override
                public void run() {
                    int i=0;
                    while(true){
    
                        if(Thread.currentThread().isInterrupted()){
                            System.out.println("Interrupted  :"+Thread.currentThread().getName());
                            break;
                        }
                        System.out.println(++i);
                        try {
                            //sleep会清除interrupt标记
                            Thread.sleep(1000);
    
                        } catch (InterruptedException e) {
                            System.out.println("Interruted When Sleep ");
                            Thread.currentThread().interrupt();
                        }
    
                        Thread.yield();
                    }
                }
            };
            t1.start();
            try{
                //暂停三毫秒
                TimeUnit.MILLISECONDS.sleep(3000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            //线程中断
            t1.interrupt();
        }
    }
    //输出结果
    1
    2
    3
    Interruted When Sleep 
    Interrupted  :a
    
    展开全文
  • Java多线程 interrupt中断阻塞

    千次阅读 2019-02-20 13:29:36
    ——interrupt()方法并不是中断线程,而是中断阻塞状态,或者将线程的[中断标志位]置为true。 ——对于未阻塞的线程,interrupt()只是造成[中断标志位]=true,线程本身运行状态不受影响。 ——对于阻塞的线程,...

    interrupt()方法

     

    ——interrupt()方法并不是中断线程,而是中断阻塞状态,或者将线程的[中断标志位]置为true。


    ——对于未阻塞的线程,interrupt()只是造成[中断标志位]=true,线程本身运行状态不受影响。


    ——对于阻塞的线程,interrupt()会中断阻塞状态,使其转换成非阻塞状态,并清除[中断标志位]。


    ——造成阻塞状态的情况有:sleep()、wait()和join()。


    ——阻塞状态的线程被中断时,只是中断了阻塞状态,即sleep()、wait()和join(),线程本身还在继续运行。

     

    实例演示

    1 非阻塞线程调用interrupt()方法    只是将中断标志位设置为true 不会影响线程正常运行

    public class interrupteDemo {
    	private static final Logger LOGGER=Logger.getAnonymousLogger();
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		LOGGER.info("interrupt()并不是中断线程 而是将线程中断标志位设置为true");
    		new Thread(
    				()->
    				{
    					Thread thread=Thread.currentThread();
    					for(int i=0;i<5;i++)
    					{
    						LOGGER.info("线程"+thread.getName()+"i="+i+"isInterrupted="+thread.isInterrupted());;
    						if(i==2)
    						{
    							thread.interrupt();
    						}
    					}
    					LOGGER.info("线程"+thread.getName()+"停止运行"+"isInterrupted="+thread.isInterrupted());
    				}
    				
    				
    				).start();
    		
    
    	}
    
    }

     2 通过interrupt()与isInterrupted()控制for循环的运行状态(非阻塞线程)  即根据中断标志位 进行控制

     

    new Thread(
    				()->
    				{
    					Thread thread=Thread.currentThread();
    					for(int i=0;i<5&&!thread.isInterrupted();i++)
    					{
    						LOGGER.info("线程"+thread.getName()+"i="+i+"isInterrupted="+thread.isInterrupted());;
    						if(i==2)
    						{
    							thread.interrupt();
    						}
    					}
    					LOGGER.info("线程"+thread.getName()+"停止运行"+"isInterrupted="+thread.isInterrupted());
    				}
    				
    				
    				).start();

    可以看到执行到i=2之后不在执行 

     

    3  阻塞线程(sleep/wait/joni)中的while循环应用interrupt()和isInterrupted()

     

    System.out.println();
    		LOGGER.info("在有阻塞状态(sleep/wait/joni)的while循环中应用interrupt()和isInterrupted()");
    		Thread thread2 = new Thread(() -> {
    		    //如果当前线程没被中断,则一直进行
    		    while (!Thread.currentThread().isInterrupted()) {
    		        LOGGER.info("线程[" + Thread.currentThread().getName() + "]正在运行...");
    		        try {
    		            Thread.sleep(5000);
    		        } catch (InterruptedException e) {
    		            e.printStackTrace();
    		        }
    		    }
    		    LOGGER.info("线程[" + Thread.currentThread().getName() + "]停止运行");
    		});
    		thread2.start();
    	    Thread.sleep(200);
    		thread2.interrupt();

    创建了thread2执行run后 由于sleep睡眠5秒 进入阻塞态

    而主线程调用 thread2.interrupt将修改thread2的中断位 

    使得还在5秒钟睡眠时间内的线程被打断 抛出异常

    但是程序还是会继续运行

     

    由此可以发现这种方式 并不能跳出循环 不是想要的结果

     

    解决方案: 将catch块外移动 

     

    Thread thread2 = new Thread(() -> {
    		    //如果当前线程没被中断,则一直进行
    			try {
    		    while (!Thread.currentThread().isInterrupted()) {
    		        LOGGER.info("线程[" + Thread.currentThread().getName() + "]正在运行...");
    		        
    		            Thread.sleep(5000);
    		        } 
    		    }catch (InterruptedException e) {
    		    	
    		    	 LOGGER.info("线程[" + Thread.currentThread().getName() + "]停止运行");
    	          
    	        }
    		   
    		});
    		thread2.start();
    	    Thread.sleep(200);
    		thread2.interrupt();

    可以看到成功的在调用interrupt之后结束循环

    由此可见对阻塞线程的控制一般方法

    //在线程定义类中
    @Override
    public void run(){
        try{
            //阻塞代码:sleep、join和wait
        }catch(InterruptedException e){
            //注释掉e.printStackTrace();
            //添加其他业务代码
        }
    }
    
    //在线程使用时
    thread.interrupt();
    

     


     

    展开全文
  • Java多线程——1 中断线程

    千次阅读 2013-08-08 00:59:03
    线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序本身。线程会不时地检测这个中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。它并不像stop方法那样会中断一个正在...

    一、中断线程(标识true)

    线程的thread.interrupt()方法是中断线程,将会设置该线程为中断状态,即设置为true。线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序本身。线程会不时地检测这个中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。它并不像stop方法那样会中断一个正在运行的线程。
     


    二、判断线程是否被中断

    请使用Thread.currentThread().isInterrupted()方法(因为它将线程中断标识位设置为true后,不会立刻清除中断标识位,即不会将中断标设置为false),而不要使用thread.interrupted()(该方法调用后会将中断标标位清除,即重新设置为false)方法来判断

     

     

    isInterrupted()源代码:

    return currentThread().isInterrupted(true);


    interrupted()源代码:

     

    return isInterrupted(false);


    而isInterrupted()则是采用JNI接口,测试线程是否被中断,并设置中断状态。

     

    三、如何中断线程

    如果一个线程处于了阻塞状态(如线程调用了thread.sleep、thread.join、thread.wait、1.5中的condition.await、以及可中断的通道上的 I/O 操作方法后可进入阻塞状态),则在线程在检查中断标识时如果发现中断标示为true,则会在这些阻塞方法(sleep、join、wait、1.5中的condition.await及可中断的通道上的 I/O 操作方法)调用处抛出InterruptedException异常,并且在抛出异常后立即将线程的中断标别位清除,即重新设置为false。抛出异常是为了线程从阻塞状态醒过来,并在结束线程前让程序员有足够的时间来处理中断请求。


    注:synchronized在获锁的过程中是不能被中断的,意思是说如果产生了死锁,则不可能被中断(请参考后面的测试例子)。与synchronized功能相似的reentrantLock.lock()方法也是一样,它也不可中断的,即如果发生死锁,那么reentrantLock.lock()方法无法终止,如果调用时被阻塞,则它一直阻塞到它获取到锁为止。但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit),那么如果线程在等待时被中断,将抛出一个InterruptedException异常,这是一个非常有用的特性,因为它允许程序打破死锁。你也可以调用reentrantLock.lockInterruptibly()方法,它就相当于一个超时设为无限的tryLock方法。(关于synchronized及reentrantLock内容会在接下来的章节讲)

     

     

    四、中断简单应用

    使用中断信号量中断非阻塞状态的线程
    中断线程最好的,最受推荐的方式是使用共享变量(shared variable)发出信号,告诉线程必须停止正在运行的任务。线程必须周期性的核查这一变量,然后有秩序地中止任务

    public class Test1 extends Thread
    	{ 
    		volatile boolean run = false;
    		
    		public static void main(String[] args) throws Exception
    		{
    			Test1 thread = new Test1();
    			System.out.println("begin application");
    			
    			thread.start();
    			
    			Thread.currentThread().sleep(2000);
    			
    			System.out.println("ask to stop");
    			thread.run = true;
    			
    		}
    		
    		
    		public void run()
    		{
    			System.out.println("begin run");
    			for(;;)
    			{
    				if(run)
    				{
    					break;
    				}
    				else
    				{
    					long time = System.currentTimeMillis();
    					
    				   try
    				{
    					Thread.sleep(500);
    				}
    				catch (InterruptedException e)
    				{
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    					System.out.println("Test1.run...."+System.currentTimeMillis());
    			
    				}
    			}
    			System.out.println("stop application");
    		}
    	}

     

    使用thread.interrupt()中断非阻塞状态线程
    虽然上面案例要求一些编码,但并不难实现。同时,它给予线程机会进行必要的清理工作。这里需注意一点的是需将共享变量定义成volatile 类型或将对它的一切访问封入同步的块/方法(synchronized blocks/methods)中。

     

     

    public class Test2 extends Thread
    	{
    		public static void main(String[] args) throws Exception
    		{
    			Test2 thread = new Test2();
    			System.out.println("begin application");
    
    			thread.start();
    			Thread.currentThread().sleep(2000);
    
    			System.out.println("ask to stop");
    			thread.interrupt();
    
    		}
    
    		public void run()
    		{
    			System.out.println("begin run");
    			System.out.println("中断状态:"+Thread.currentThread().isInterrupted());
    			
    			while (!Thread.currentThread().isInterrupted())
    			{
    				long time = System.currentTimeMillis();
    
    				while(System.currentTimeMillis()-time <500)
    				{
    				}
    				
    				System.out
    						.println("Test1.run...." + System.currentTimeMillis());
    
    			}
    			System.out.println("中断状态:"+Thread.currentThread().isInterrupted());
    			System.out.println("stop application");
    		}
    	}
    

    使用thread.interrupt()中断阻塞状态线程
    Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是,设置线程的中断标示位,在线程受到阻塞的地方(如调用sleep、wait、join等地方)抛出一个异常InterruptedException,并且中断状态也将被清除,这样线程就得以退出阻塞的状态。


    线程阻塞如果线程收到中断操作信号将抛出异常

     

     

    public class Test3 extends Thread
    	{
    		public static void main(String[] args) throws Exception
    		{
    			Test3 thread = new Test3();
    			System.out.println("begin application");
    
    			thread.start();
    			Thread.currentThread().sleep(2000);
    
    			System.out.println("ask to interrupt");
    			thread.interrupt();
    			System.out.println("ask to stop");
    			Thread.currentThread().sleep(1000);
    			thread.stop();
    			System.out.println("stop application");
    			
    		}
    
    		public void run()
    		{
    			System.out.println("begin run");
    			System.out
    					.println("中断状态:" + Thread.currentThread().isInterrupted());
    
    			while (!Thread.currentThread().isInterrupted())
    			{
    				long time = System.currentTimeMillis();
    
    				try
    				{
    					Thread.sleep(500);
    				}
    				catch (InterruptedException e)
    				{
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    
    				System.out
    						.println("Test1.run...." + System.currentTimeMillis());
    				System.out
    				.println("中断状态:" + Thread.currentThread().isInterrupted());
    			}
    			
    		}
    	}

    死锁状态线程无法被中断

     

    五、中断I/O操作(在以后NIO中会进一步讲)

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


    实现此InterruptibleChannel接口的通道是可中断的:如果某个线程在可中断通道上因调用某个阻塞的 I/O 操作(常见的操作一般有这些:serverSocketChannel. accept()、socketChannel.connect、socketChannel.open、socketChannel.read、socketChannel.write、fileChannel.read、fileChannel.write)而进入阻塞状态,而另一个线程又调用了该阻塞线程的 interrupt 方法,这将导致该通道被关闭,并且已阻塞线程接将会收到ClosedByInterruptException,并且设置已阻塞线程的中断状态。另外,如果已设置某个线程的中断状态并且它在通道上调用某个阻塞的 I/O 操作,则该通道将关闭并且该线程立即接收到 ClosedByInterruptException;并仍然设置其中断状态。如果情况是这样,其代码的逻辑和第三个例子中的是一样的,只是异常不同而已。


    如果你正使用通道(channels)(这是在Java 1.4中引入的新的I/O API),那么被阻塞的线程将收到一个ClosedByInterruptException异常。但是,你可能正使用Java1.0之前就存在的传统的I/O,而且要求更多的工作。既然这样,Thread.interrupt()将不起作用,因为线程将不会退出被阻塞状态。尽管interrupt()被调用,线程也不会退出被阻塞状态,比如ServerSocket的accept方法根本不抛出异常。


    很幸运,Java平台为这种情形提供了一项解决方案,即调用阻塞该线程的套接字的close()方法。在这种情形下,如果线程被I/O操作阻塞,当调用该套接字的close方法时,该线程在调用accept地方法将接收到一个SocketException(SocketException为IOException的子异常)异常,这与使用interrupt()方法引起一个InterruptedException异常被抛出非常相似,(注,如果是流因读写阻塞后,调用流的close方法也会被阻塞,根本不能调用,更不会抛IOExcepiton,此种情况下怎样中断?我想可以转换为通道来操作流可以解决,比如文件通道)。

     

     

     

     

    展开全文
  • 多线程IO阻塞中断

    千次阅读 2016-10-18 16:22:38
    关于Java多线程IO阻塞如何中断的问题,基于一个基本条件,关闭任务发生阻塞的底层资源问题,可以中断多线程任务。对于IO阻塞问题,给出了两个示例,一个是Socket IO,关闭掉Socket IO之后确实可以中断;另一种是...
  • 这篇文章主要记录使用 interrupt() 方法中断线程,以及如何对InterruptedException进行处理。感觉对InterruptedException异常进行处理是一件谨慎且技巧的活儿。 由于使用stop()方法停止线程非常的暴力,人家线程...
  • 多线程编程 线程的中断(interrupt)

    千次阅读 2014-10-13 17:56:27
    如果你也这么认为,那你对多线程编程还没有入门. 在java中,线程的中断(interrupt)只是改变了线程的中断状态,至于这个中断状态改变后 带来的结果,那是无法确定的,有时它更是让停止中的线程继续执行的唯一手段.不但...
  • java多线程中断(interrupt)问题

    千次阅读 2017-07-21 09:23:08
    摘要在java中,想要让一个线程停下来,三种办法: (1)采用退出标志,使得run方法执行完之后线程自然终止。 (2)使用stop强行终止线程,但该方法由于安全问题已经被deprecated。 (3)使用中断机制。
  • java多线程--中断线程

    千次阅读 2016-06-23 15:39:33
    2. 终止线程的方式 Thread中的stop()和suspend()方法,由于固有的不安全性,已经...通常,我们通过“中断”方式终止处于“阻塞状态”的线程。 当线程由于被调用了sleep(), wait(), join()等方法而进入阻塞状态;若此
  • 方法一: @Override public void ...最好的建议就是将大数据的 IO 读写操作放在循环中进行,这样可以在每次循环中都有线程停止的时机,这也将问题转化成了如何停止正在运行中的线程的问题了。
  • Qt:多线程中断

    千次阅读 2016-07-27 11:18:22
    线程使用两种方法,具体介绍见...关于线程中断的函数:quit() Exit() terminate();除此之外比较常用的函数(起到阻塞作用):wait() sleep() ; 在线程类被析构的时候,应该习惯性的设置中断和阻塞;避免出现一些不必要
  • 今天开始就来总结一下java多线程的基础知识点,下面是本篇的主要内容(大部分知识点参考java核心技术卷1): 1.什么是线程以及多线程与进程的区别 2.多线程的创建与启动 3.中断线程和守护线程以及线程优先级 4....
  • 线程响应中断

    千次阅读 2019-08-19 08:44:50
    首先介绍下Thread的两个方法: ...isInterrupted():检查线程中断标记 @Slf4j public class StopThread implements Runnable { public static void main(String[] args) throws InterruptedException { ...
  • JAVA 多线程同步与中断

    千次阅读 2012-05-07 17:44:58
    1 Thread.sleep()是可中断的阻塞;IO引起的阻塞不可中断;synchronized引起的阻塞不可中断。 2 “IO引起的阻塞不可中断”的解决方案:关闭底层资源,即关闭IO流。 3 wait(),notify(),notifyAll()只能在同步方法...
  • 说来惭愧这个问题找了挺久,作为一个并发编程渣渣,甚至都不知道怎么用idea进行多线程调试,这次虽然找问题找了半天,但也算有点收获 场景是我要开一个线程去定期用各种参数请求一个接口,来缓存这个接口的结果,...
  • 多线程——2如何正确的中断线程

    千次阅读 2019-11-02 10:28:33
    多线程探险——2常用方法 一、内容安排 什么是守护线程(Daemon Thread) Join方法的含义 自己join自己会是什么效果 Interrupt方法 综合案列:如何去停止线程 二、文章内容 1. 什么...
  • C++ Boost 多线程(三),线程的中断

    千次阅读 2018-05-27 10:35:11
    //线程中断 int main() { boost::thread t1(func1, 11); t1.interrupt(); boost::thread t2(func2, 22); t2.interrupt(); boost::thread t3(func3, 33); t3.interrupt(); t1.join(); t2.join(); t3.join()...
  • 线程中断与暴力停止

    万次阅读 2020-09-21 14:04:59
    线程中断 stop()方法的线程不安全性 Thread.stop()方法可以停止一个运行中的线程,但是这个方法已经被弃用了,这是为什么呢? 先看下面一段代码: package com.morris.concurrent.thread.interrupt; import java....
  • 中断线程

    千次阅读 2016-09-12 16:59:03
    线程中断后的结果是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序本身。线程会不时地检测这个中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。它并不像stop方法那样会中断一个正在...
  • java线程中断机制interrupt

    千次阅读 2019-07-10 10:32:57
    现在把这三个方法同一放到这里来讲,因为这三个方法都涉及到多线程的一个知识点----中断机制。 Java没有提供一种安全、直接的方法来停止某个线程,而是提供了中断机制。中断机制是一种协作机制,也就是说通过中断并...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java多线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • boost线程中断

    千次阅读 2017-04-14 11:38:14
    模拟功能:线程中断 boost::this_thread::interruption_point() 一个对话框应用程序,界面上两个按钮,一个是“开始”一个是“退出”,点击“开始”时创建一个线程, 这个线程会执行一个任务,whatever,可能是下载...
  • 线程中断详解

    万次阅读 多人点赞 2018-07-05 19:01:44
    中断线程线程的thread.interrupt()方法是中断线程,将会设置该线程中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 252,032
精华内容 100,812
关键字:

多线程有中断吗