- 浏览: 1536418 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (673)
- Linux (3)
- android (302)
- php (12)
- struts2 (1)
- Flex积累 (88)
- Hibernate (8)
- MyEclipse (18)
- android备忘录 (209)
- Java备忘录 (53)
- spring (0)
- Flex备忘录 (30)
- JavaScript (10)
- Tomcat (11)
- Flex FrameWork (0)
- 设计模式学习 (4)
- 休闲娱乐 (4)
- Flex skin (1)
- Flex 组件 (2)
- 持久化相关 (2)
- DotNet相关 (5)
- Flex Style (1)
- Windows (11)
- Flex AIR (9)
- MySQL (1)
- mac OSX (29)
- eclipse (26)
- database (5)
- ARM (1)
- English (1)
- WebService (8)
- javabase64 (2)
- ruby (1)
- sqlite (5)
- ios (7)
- 无线应用 (1)
- Java (3)
- goagent (1)
- oc (1)
最新评论
-
Z_ying:
谢谢分享,上次也遇到过的,解决了,过了一段时间又忘记,幸亏看到 ...
FastJson 示例 及问题 -
wto8559:
这是什么错啊,我也遇到了.问下写一个servlet能解决什么问 ...
Exception in thread "HouseKeeper" java.lang.NullPointerException -
zxjlwt:
如何用php怎么弄了。http://surenpi.com
\U672a\U77e5\U9519\U8bef 字符还原 -
windseamless:
那怎么样才能屏蔽呢
java.lang.IllegalArgumentException: Window type can not be changed after the -
macleo:
Trinea 写道还是利用Fiddler抓包更方便,(1)无需 ...
android网络抓包相关
转载自:http://www.blogjava.net/fhtdy2004/archive/2009/08/22/292181.html
在学校的论坛Java版发现很多问关于这样的问题,比如这几个方法有什么区别,想看t.interrupt()方法后线程的中断状态;如何终止一个线程
其实之前已经大部分提及到。现总结一下,然后加上例子,毕竟例子容易理解
http://www.blogjava.net/fhtdy2004/archive/2009/06/08/280728.html中有关interrupt()的解释已经很清楚了
interruptpublic void interrupt()
中断线程。
如果当前线程没有中断它自己(这在任何情况下都是允许的),则该线程的 checkAccess 方法就会被调用,这可能抛出 SecurityException。
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法,或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException。
如果该线程在可中断的通道上的 I/O 操作中受阻,则该通道将被关闭,该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。
如果该线程在一个 Selector 中受阻,则该线程的中断状态将被设置,它将立即从选择操作返回,并可能带有一个非零值,就好像调用了选择器的 wakeup 方法一样。
如果以前的条件都没有保存,则该线程的中断状态将被设置。
抛出:
SecurityException - 如果当前线程无法修改该线程
--------------------------------------------------------------------------------
interruptedpublic static boolean interrupted()
测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false(在第一次调用已清除了其中断状态之后,且第二次调用检验完中断状态前,当前线程再次中断的情况除外)。
返回:
如果当前线程已经中断,则返回 true;否则返回 false。
另请参见:
isInterrupted()
--------------------------------------------------------------------------------
isInterruptedpublic boolean isInterrupted()
测试线程是否已经中断。线程的中断状态 不受该方法的影响。
返回:
如果该线程已经中断,则返回 true;否则返回 false。
另请参见:
interrupted()
t.interrupt()不会中断正在执行的线程,只是将线程的标志位设置成true。但是如果线程在调用sleep(),join(),wait()方法时线程被中断,则这些方法会抛出InterruptedException,在catch块中捕获到这个异常时,线程的中断标志位已经被设置成false了,因此在此catch块中调用t.isInterrupted(),Thread.interrupted()始终都为false,
而t.isInterrupted与Thread.interrupted()的区别是API中已经说明很明显了,Thread.interrupted()假如当前的中断标志为true,则调完后会将中断标志位设置成false
stop必须是volatile的,这样才能确保run( )方法能看到它(否则它会使用本地的缓存值)。这个线程的"任务"是打印10,000个数字,所以当counter >= 10000或有人要它停下来的时候,它就结束了。注意requestStop( )不是synchronized,因为stop既是boolean(改成true是一个原子操作)又是volatile的。
或者
3.避免过多的同步,永远不要在循环外面调用wait
为了避免死锁的危险,在一个被同步的的方法或者代码快中,永远不要放弃对客户的限制。
换句话说,在一个被同步的区域内部,不要调用一个可被改写的公有或受保护的方法(这样的方法往往是一个抽象方法,但偶尔他们也会有一个默认的实现,)从包含该同步区域的类的角度来看,这样的方法是一个外来者alien。这个类不知道该类会做什么事情,也控制不力它。客户可以为这个外来方法提供一个实现,并且在该方法中创建了一个线程,再回调到这个类中。然后,新建的线程试图获取原线程所拥有的那把锁,这样会导致新建的线程被阻塞。如果创建该线程的方法在等待这个线程完成这个任务,则死锁就形成了。
Object.wait方法的作用是使一个线程等待某个条件。它一定是在一个同步区域中被调用,而且该同步区域锁住了被调用的对象。下面是wait方法的标准模式:
4.保持可运行线程数量尽可能的少的主要技术是,让每个线程做少量的工作,然后使用Object.wait等待某个条件发生,或者使用Thread.sleep()睡眠一段时间,线程不应该忙-等busy-wait,即反复的检查一个数据结构,以等待某些事件发生。除了使程序易受调度器的变化的影响外,忙等这种做法还会增加处理器的负担
busy-wait
在学校的论坛Java版发现很多问关于这样的问题,比如这几个方法有什么区别,想看t.interrupt()方法后线程的中断状态;如何终止一个线程
其实之前已经大部分提及到。现总结一下,然后加上例子,毕竟例子容易理解
http://www.blogjava.net/fhtdy2004/archive/2009/06/08/280728.html中有关interrupt()的解释已经很清楚了
interruptpublic void interrupt()
中断线程。
如果当前线程没有中断它自己(这在任何情况下都是允许的),则该线程的 checkAccess 方法就会被调用,这可能抛出 SecurityException。
如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法,或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException。
如果该线程在可中断的通道上的 I/O 操作中受阻,则该通道将被关闭,该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。
如果该线程在一个 Selector 中受阻,则该线程的中断状态将被设置,它将立即从选择操作返回,并可能带有一个非零值,就好像调用了选择器的 wakeup 方法一样。
如果以前的条件都没有保存,则该线程的中断状态将被设置。
抛出:
SecurityException - 如果当前线程无法修改该线程
--------------------------------------------------------------------------------
interruptedpublic static boolean interrupted()
测试当前线程是否已经中断。线程的中断状态 由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false(在第一次调用已清除了其中断状态之后,且第二次调用检验完中断状态前,当前线程再次中断的情况除外)。
返回:
如果当前线程已经中断,则返回 true;否则返回 false。
另请参见:
isInterrupted()
--------------------------------------------------------------------------------
isInterruptedpublic boolean isInterrupted()
测试线程是否已经中断。线程的中断状态 不受该方法的影响。
返回:
如果该线程已经中断,则返回 true;否则返回 false。
另请参见:
interrupted()
t.interrupt()不会中断正在执行的线程,只是将线程的标志位设置成true。但是如果线程在调用sleep(),join(),wait()方法时线程被中断,则这些方法会抛出InterruptedException,在catch块中捕获到这个异常时,线程的中断标志位已经被设置成false了,因此在此catch块中调用t.isInterrupted(),Thread.interrupted()始终都为false,
而t.isInterrupted与Thread.interrupted()的区别是API中已经说明很明显了,Thread.interrupted()假如当前的中断标志为true,则调完后会将中断标志位设置成false
package threadtest; import java.util.Timer; import java.util.TimerTask; class CanStop extends Thread { private int counter = 0; public void run() { boolean done = false; try{ Thread.sleep(100);//设置成100比主线程中的500要小 }catch(InterruptedException ie){ ie.printStackTrace(); //return;假如要使用interrupt来终止线程则在捕获的InterruptedException中return } while (counter < 100000 &&!done) { System.out.println(counter++); //在主线程中调用stoppable.interrupt()之前为false,假如之后没有调用Thread.interrupted()则一直为true, //否则为第一次为true,调用Thread.interrupted之后为false System.out.println("in thread stoppable.isInterrupted() "+isInterrupted()); //System.out.println("stoppable.isInterrupted() "+Thread.interrupted());////在主线程中调用stoppable.interrupt()之前为false,之后只有第一个会显示为true,之后全为false //调用Thread.interrupted()一次会清除线程的中断标志位,因此以后都为false if(Thread.interrupted()==true){ try{ //Thread.interrupted()会清除中断标志位,显然这里面只会调用一次 System.out.println("in thread after Thread.interrupted() "+isInterrupted()); sleep(10000); }catch(InterruptedException ie){ ie.printStackTrace(); } } } } } public class CheckInterrupt { public static void main(String[] args) { final CanStop stoppable = new CanStop(); stoppable.start(); new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Requesting Interrupt"); stoppable.interrupt();//不会中断正在执行的线程,原因是因为interrupt()方法只设置中断状态标志位为true System.out.println("in timer stoppable.isInterrupted() "+stoppable.isInterrupted()); } }, 500); // run() after 500 milliseconds } } 2,关于interrupte()打断sleep() package threadtest; //Understanding join(). class Sleeper extends Thread { private int duration; public Sleeper(String name, int sleepTime) { super(name); duration = sleepTime; start(); } public void run() { try { sleep(duration); } catch (InterruptedException e) { // System.out.println(getName() + " was interrupted. " + // "isInterrupted(): " + isInterrupted()); System.out.println(getName() + " in catch Thread.interrupted(). " + "Thread.interrupted(): " + Thread.interrupted()); return; } System.out.println(getName() + " has awakened"); } } class Joiner extends Thread { private Sleeper sleeper; public Joiner(String name, Sleeper sleeper) { super(name); this.sleeper = sleeper; start(); } public void run() { try { sleeper.join(); } catch (InterruptedException e) { //run方法不能Throw CheckedException,要抛只能抛出RuntimeException,也不会被主线程捕获 //要使主线程能够捕获这个RuntimeException请参见另外一篇文章 //地址:http://www.blogjava.net/fhtdy2004/archive/2009/08/07/290210.html throw new RuntimeException(e); } System.out.println(getName() + " join completed"); } } public class Joining { public static void main(String[] args) { Sleeper sleepy = new Sleeper("Sleepy", 1500), grumpy = new Sleeper("Grumpy", 1500); Joiner dopey = new Joiner("Dopey", sleepy), doc = new Joiner("Doc",grumpy); grumpy.interrupt(); //doc.interrupt(); } } Sleeper是一个会睡上一段时间的Thread,至于睡多长时间,这要由构造函数的参数决定。Sleeper的run( )的sleep( )可以因时限到期而返回,也可以被interrupt( )打断。catch语句在报告中断的同时,会一并报告isInterrupted( )。当有别的线程调用了本线程的interrupt( )时,会设置一个标记以表示这个这个线程被打断了。当本线程捕获这个异常的时候,会清除这个标志。所以catch语句会永远报告说isInterrupted( )是false。这个标记是用来应付其它情况的,或许在没出异常的情况下,线程要用它来检查自己是不是被中断了。 Joiner是另一个线程,它调用了Sleeper的join( ),所以它要等Sleeper醒过来。main( )创建了两个Sleeper分派给两个Joiner。你会发现,不论Sleeper是被打断还是正常结束,Joiner都会随Sleeper一道结束。 2,如何终止一个线程: package test.thread.one; import java.util.Timer; import java.util.TimerTask; class CanStop extends Thread { // Must be volatile: private volatile boolean stop = false; private int counter = 0; public void run() { while (!stop && counter < 100000) { System.out.println(counter++); } if (stop) System.out.println("Detected stop"); } public void requestStop() { stop = true; } } public class Stopping { public static void main(String[] args) { final CanStop stoppable = new CanStop(); stoppable.start(); new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Requesting stop"); stoppable.requestStop(); } }, 500); // run() after 500 milliseconds } }
stop必须是volatile的,这样才能确保run( )方法能看到它(否则它会使用本地的缓存值)。这个线程的"任务"是打印10,000个数字,所以当counter >= 10000或有人要它停下来的时候,它就结束了。注意requestStop( )不是synchronized,因为stop既是boolean(改成true是一个原子操作)又是volatile的。
或者
package test.thread.three; import java.util.Timer; import java.util.TimerTask; class CanStop extends Thread { private boolean stop = false; private int counter = 0; public void run() { boolean done = false; try{ Thread.sleep(100); }catch(InterruptedException ie){ ie.printStackTrace(); //return;假如要使用interrupt来终止线程则在捕获的InterruptedException中return } while (!getStopRequest() && counter < 100000 &&!done) { System.out.println(counter++); } if (getStopRequest()) System.out.println("Detected stop"); } public synchronized boolean getStopRequest(){ return stop; } public synchronized void requestStop() { stop = true; } } public class Stopping { public static void main(String[] args) { final CanStop stoppable = new CanStop(); stoppable.start(); new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Requesting stop"); stoppable.requestStop(); } }, 500); // run() after 500 milliseconds } } 打断受阻的线程 有时线程受阻之后就不能再做轮询了,比如在等输入,这时你就不能像前面那样去查询旗标了。碰到这种情况,你可以用Thread.interrupt( )方法打断受阻的线程: //: c13:Interrupt.java // Using interrupt() to break out of a blocked thread. import java.util.*; class Blocked extends Thread { public Blocked() { System.out.println("Starting Blocked"); start(); } public void run() { try { synchronized(this) { wait(); // Blocks } } catch(InterruptedException e) { System.out.println("Interrupted"); } System.out.println("Exiting run()"); } } public class Interrupt { static Blocked blocked = new Blocked(); public static void main(String[] args) { new Timer(true).schedule(new TimerTask() { public void run() { System.out.println("Preparing to interrupt"); blocked.interrupt(); blocked = null; // to release it } }, 2000); // run() after 2000 milliseconds } } ///
3.避免过多的同步,永远不要在循环外面调用wait
为了避免死锁的危险,在一个被同步的的方法或者代码快中,永远不要放弃对客户的限制。
换句话说,在一个被同步的区域内部,不要调用一个可被改写的公有或受保护的方法(这样的方法往往是一个抽象方法,但偶尔他们也会有一个默认的实现,)从包含该同步区域的类的角度来看,这样的方法是一个外来者alien。这个类不知道该类会做什么事情,也控制不力它。客户可以为这个外来方法提供一个实现,并且在该方法中创建了一个线程,再回调到这个类中。然后,新建的线程试图获取原线程所拥有的那把锁,这样会导致新建的线程被阻塞。如果创建该线程的方法在等待这个线程完成这个任务,则死锁就形成了。
Object.wait方法的作用是使一个线程等待某个条件。它一定是在一个同步区域中被调用,而且该同步区域锁住了被调用的对象。下面是wait方法的标准模式:
synchronized(obj){ while(<condition does not hold>) obj.wait(); ...//perform action appropriate to condition }总是使用wait循环模式来调用wait方法。而不是if来调用。永远不要在循环的外面调用wait。循环被用于等待的前后测试条件
package effective.java; import java.io.BufferedInputStream; import java.util.LinkedList; import java.util.List; public abstract class WorkQueue { private final List queue = new LinkedList(); private boolean stopped = false; StringBuffer sb; BufferedInputStream bis; protected WorkQueue(){ new WorkerThread2().start(); } public final void enqueue(Object workItem){ synchronized(queue){ queue.add(workItem); queue.notify(); } } public final void stop(){ synchronized(queue){ stopped = true; queue.notify(); } } protected abstract void processItem(Object workItem)throws InterruptedException; //Broken - invokes alien method from synchronized block private class WorkerThread extends Thread{ public void run(){ while(true){ synchronized(WorkQueue.this.queue){ try{ while(queue.isEmpty() && !stopped){ queue.wait(); } }catch(InterruptedException ie){ ie.printStackTrace(); return; } if(stopped) return; Object workItem = queue.remove(0); try{ processItem(workItem);//lock held }catch(InterruptedException ie){ System.out.println("ddd"+ie); return; } } } } } //Alien method outside synchronized block -"open call" private class WorkerThread2 extends Thread{ public void run(){ while(true){ Object workItem = null; synchronized(WorkQueue.this.queue){ try{ while(queue.isEmpty() && !stopped){ queue.wait(); } }catch(InterruptedException ie){ return; } if(stopped) return; workItem = queue.remove(0); } try{ processItem(workItem);//No lock held }catch(InterruptedException ie){ return; } } } } } package effective.java; public class DisplayQueue extends WorkQueue { @Override protected void processItem(Object workItem) throws InterruptedException { System.out.println(workItem); System.out.println("模拟此线程做耗时工作"); Thread.sleep(1000); } public static void main(String[] args){ WorkQueue wq = new DisplayQueue(); for(int i=0;i<10;i++){ String s = new String("object_"+i); System.out.println("main thread add " + s+" to queue"); wq.enqueue(s); try{ Thread.sleep(500); }catch(InterruptedException ie){ ie.printStackTrace(); } } //wq.stop(); } } class DeadLockQueue extends WorkQueue{ @Override protected void processItem(final Object workItem) throws InterruptedException { Thread child = new Thread(){ public void run(){ //DeadLockQueue.this.enqueue(workItem); System.out.println("在将对象入队列 "+workItem); enqueue(workItem); } }; child.start(); child.join();//dead lock } }
4.保持可运行线程数量尽可能的少的主要技术是,让每个线程做少量的工作,然后使用Object.wait等待某个条件发生,或者使用Thread.sleep()睡眠一段时间,线程不应该忙-等busy-wait,即反复的检查一个数据结构,以等待某些事件发生。除了使程序易受调度器的变化的影响外,忙等这种做法还会增加处理器的负担
busy-wait
package effective.java; import java.util.LinkedList; import java.util.List; public abstract class WorkQueueBusyWait { private final List queue = new LinkedList(); private boolean stopped = false; protected WorkQueueBusyWait(){ new WorkThread().start(); } public final void enqueue(Object workItem){ synchronized(queue){ queue.add(workItem); } } public final void stop(){ synchronized(queue){ stopped = true; } } protected abstract void processItem(Object workitem) throws InterruptedException; private class WorkThread extends Thread{ public void run(){ final Object QUEUE_IS_EMPTY = new Object(); while(true){ Object workItem = QUEUE_IS_EMPTY; synchronized(queue){ if(stopped) return; if(!queue.isEmpty()) workItem = queue.remove(0); } if(workItem != QUEUE_IS_EMPTY){ try{ processItem(workItem); }catch(InterruptedException ie){ ie.printStackTrace(); return; } } } } } } class PingPongQueue extends WorkQueue{ volatile int count=0; @Override protected void processItem(final Object workItem) throws InterruptedException { count++; WorkQueue recipient = (WorkQueue)workItem; recipient.enqueue(this); } } package effective.java; public class WaitQueuePerf { /** *//** * @param args */ public static void main(String[] args) { PingPongQueue q1 = new PingPongQueue(); PingPongQueue q2 = new PingPongQueue(); q1.enqueue(q2); try{ Thread.sleep(1000); }catch(InterruptedException ie){ ie.printStackTrace(); } int count = q1.count; try{ Thread.sleep(1000); }catch(InterruptedException ie){ ie.printStackTrace(); } System.out.println(q1.count-count); q1.stop(); q2.stop(); } }
相关推荐
一般来说,支持线程中断的方法(也就是线程中断后会抛出InterruptedException的方法),阻塞函数,如:Thread.sleep、Thread.jo
Thread.interrupt()方法的使用以及使用它退出线程
java线程中的interrupt,isInterrupt,interrupted方法
线程的基本概念、线程类、任务类、线程优先级、sleep()方法(休眠)、yield()方法(礼让)、join方法(合并)、interrupt()方法(中断),线程的生命周期 线程 与 进程 的关系:**有一个进程中至少包含一个线程 **...
中断在java中主要有3个方法,interrupt(),isInterrupted()和interrupted()。 interrupt(),在一个线程中调用另一个线程的interrupt()方法,即会向那个线程发出信号——线程中断状态已被设置。至于那个线程何去何从...
interrupt,interrupted,isInterrupted方法区别 join方法 yield方法 多线程 进程和线程 进程与线程最主要的区别是它们是操作系统管理资源的不同方式的体现。 准确来说进程与线程属于衍生关系。 进程是操作系统执行...
调用 interrupt() 方法来通知 通过共享的标记来实现中断 就是创建一个boolean类型的变量来控制循环是否进行,就是一个标记。 代码如下: /** * 描述:标记法中断线程 */ public class ThreadDemo { private static...
本人利用Thread.Abort()与Thread.Interrupt()可以引起目标线程异常的特点,开发了一种不使用已过时的方法来变相从外部控制线程的挂起与恢复的技术,原理简单,方便理解。 相关技术参考:...
方法结束线程使用interrupt()方法来中断线程有两种情况: 1. 线程处于阻塞状态:如使用了sleep,同步锁的wait,socket中的receiver,accept等方法时,会使线程处于阻塞状态。当调用线程的interrupt()方法时,会抛出...
线程的thread.interrupt()方法是中断线程,将会设置该线程的中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示位,以...
interrupt code
Interrupt Example in MPLABX XC8 Compiler
com interrupt void interrupt 4 using 3
MCS51 中断interrupt
interrupt,讲述飞思卡尔HCS12系列芯片的中断处理控制。
The Generic Interrupt Controller (GIC) architecture defines: • the architectural requirements for handling all interrupt sources for any processor connected to a GIC • a common interrupt controller ...
一个线程join另一个线程,(包括和interrupt互动的用法)3---马克-to-win java视频
ARM Generic Interrupt Spec, refenrence manual for arm operating sytem development
主要介绍了Java interrupt()方法使用注意_动力节点Java学院整理,需要的朋友可以参考下
IRQ interrupt function driver