SureStop.java
上传用户:songled
上传日期:2022-07-14
资源大小:94k
文件大小:4k
源码类别:

进程与线程

开发平台:

Java

  1. import java.util.*;
  2. public class SureStop extends Object {
  3. // nested internal class for stop request entries
  4. private static class Entry extends Object {
  5. private Thread thread;
  6. private long stopTime;
  7. private Entry(Thread t, long stop) {
  8. thread = t;
  9. stopTime = stop;
  10. }
  11. }
  12. // static reference to the singleton instance
  13. private static SureStop ss;
  14. static {
  15. // When class is loaded, create exactly one instance 
  16. // using the private constructor.
  17. ss = new SureStop();
  18. }
  19. private List stopList;
  20. private List pendingList;
  21. private Thread internalThread;
  22. private SureStop() {
  23. // using a linked list for fast deletions
  24. stopList = new LinkedList();
  25. // Enough initial capacity for 20 pending additions, 
  26. // will grow automatically if necessary to keep 
  27. // ensureStop() from blocking.
  28. pendingList = new ArrayList(20);
  29. Runnable r = new Runnable() {
  30. public void run() {
  31. try {
  32. runWork();
  33. } catch ( Exception x ) {
  34. // in case ANY exception slips through
  35. x.printStackTrace(); 
  36. }
  37. }
  38. };
  39. internalThread = new Thread(r);
  40. internalThread.setDaemon(true); // no need to run alone
  41. internalThread.setPriority(Thread.MAX_PRIORITY); // high
  42. internalThread.start();
  43. }
  44. private void runWork() {
  45. try {
  46. while ( true ) {
  47. // Since this is a super-high priority thread, 
  48. // be sure to give other threads a chance to 
  49. // run each time through in case the wait on 
  50. // pendingList is very short.
  51. Thread.sleep(500);
  52. // Stop expired threads and determine the 
  53. // amount of time until the next thread is
  54. // due to expire.
  55. long sleepTime = checkStopList();
  56. synchronized ( pendingList ) {
  57. if ( pendingList.size() < 1 ) {
  58. pendingList.wait(sleepTime);
  59. }
  60. if ( pendingList.size() > 0 ) {
  61. // Copy into stopList and then remove 
  62. // from pendingList.
  63. stopList.addAll(pendingList);
  64. pendingList.clear();
  65. }
  66. }
  67. } // while
  68. } catch ( InterruptedException x ) {
  69. // ignore
  70. } catch ( Exception x ) {
  71. // Never expect this, but print a trace in case 
  72. // it happens.
  73. x.printStackTrace();
  74. }
  75. }
  76. private long checkStopList() {
  77. // called from runWork() by the internal thread 
  78. long currTime = System.currentTimeMillis();
  79. long minTime = Long.MAX_VALUE;
  80. Iterator iter = stopList.iterator();
  81. while ( iter.hasNext() ) {
  82. Entry entry = (Entry) iter.next();
  83. if ( entry.thread.isAlive() ) {
  84. if ( entry.stopTime < currTime ) {
  85. // timed out, stop it abruptly right now
  86. try {
  87. entry.thread.stop();
  88. } catch ( SecurityException x ) {
  89. // Catch this here so that other 
  90. // operations are not disrupted. Warn
  91. // that thread could not be stopped.
  92. System.err.println(
  93. "SureStop was not permitted to " +
  94. "stop thread=" + entry.thread);
  95. x.printStackTrace();
  96. }
  97. // Since it has stopped, remove it 
  98. // from stopList.
  99. iter.remove();
  100. } else {
  101. // Not yet expired, check to see if this 
  102. // is the new minimum.
  103. minTime = Math.min(entry.stopTime, minTime);
  104. }
  105. } else {
  106. // Thread died on its own, remove it from 
  107. // stopList.
  108. iter.remove();
  109. } // if alive
  110. } // while
  111. long sleepTime = minTime - System.currentTimeMillis();
  112. // ensure that it is a least a little bit of time
  113. sleepTime = Math.max(50, sleepTime); 
  114. return sleepTime;
  115. }
  116. private void addEntry(Entry entry) {
  117. // called from ensureStop() by external thread
  118. synchronized ( pendingList ) {
  119. pendingList.add(entry);
  120. // no need for notifyAll(), one waiter
  121. pendingList.notify(); 
  122. }
  123. }
  124. public static void ensureStop(Thread t, long msGracePeriod) {
  125. if ( !t.isAlive() ) {
  126. // thread is already stopped, return right away
  127. return;
  128. }
  129. long stopTime = 
  130. System.currentTimeMillis() + msGracePeriod;
  131. Entry entry = new Entry(t, stopTime);
  132. ss.addEntry(entry);
  133. }
  134. }