|
在学校的论坛Java版发现很多问关于这样的问题，比如这几个方法有什么区别，想看t.interrupt()方法后线程的中断状态；如何终止一个线程 其实之前已经大部分提及到。现总结一下，然后加上例子，毕竟例子容易理解 http://www./fhtdy2004/archive/2009/06/08/280728.html中有关interrupt()的解释已经很清楚了 interruptpublic void interrupt()
interruptedpublic static boolean interrupted()
isInterruptedpublic boolean isInterrupted()
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./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。这个标记是用来应付其它情况的，或许在没出异常的情况下，线程要用它来检查自己是不是被中断了。 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 }}或者 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 为了避免死锁的危险，在一个被同步的的方法或者代码快中，永远不要放弃对客户的限制。
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(); }} |
|
|
