Java State.WAITING属性代码示例

/** taken from sun.misc.VM
 * 
 * Returns Thread.State for the given threadStatus
 */
private static Thread.State toThreadState(int threadStatus) {
    if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
        return State.RUNNABLE;
    } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
        return State.BLOCKED;
    } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
        return State.WAITING;
    } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
        return State.TIMED_WAITING;
    } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
        return State.TERMINATED;
    } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
        return State.NEW;
    } else {
        return State.RUNNABLE;
    }
}
 

public boolean isReadable() {
  if (_thread == null) {
    return true;
  } else {
    synchronized (_thread) {
      if (_thread.getState() == State.WAITING) {
        return true;
      } else if (_thread.getState() == State.TIMED_WAITING) {
        // Make sure that it stays readable
        _tcx.waitUntilNotified(true);
        return true;
      }
      return false;
    }
  }
}
 

public void resume()
{
    if( _thread != null )
    {
        // Only force a resume when process is waiting for a notification
        if( _thread.getState() == State.WAITING )
        {
            synchronized( _tcx )
            {
                _tcx.notify();
            }
        }
        else if( _thread.getState() == State.TIMED_WAITING )
        {
            _tcx.waitUntilNotified( false );
        }
    }
}
 

public boolean isReadable()
{
    if( _thread == null )
    {
        return true;
    }
    else
    {
        synchronized( _thread )
        {
            if( _thread.getState() == State.WAITING )
            {
                return true;
            }
            else if( _thread.getState() == State.TIMED_WAITING )
            {
                // Make sure that it stays readable
                _tcx.waitUntilNotified( true );
                return true;
            }
            return false;
        }
    }
}
 

private void waitForInitialization(long threadID) throws InterruptedException {
	ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
	boolean isWaiting = true;
	
	while (isWaiting) {
		ThreadInfo threadInfo = mbean.getThreadInfo(threadID);
		if (threadInfo == null) {
			Thread.sleep(50);
			continue;
		}
		
		if (threadInfo.getThreadState() == State.WAITING)
			isWaiting = false;
		else
			Thread.sleep(50);
	}
}
 

private void setNewDataWorker() {
	if (this.dataThread != null) {
		this.dataWorker.induceStop();
		if (this.dataThread != Thread.currentThread()) {
			State state = this.dataThread.getState();
			if (state == State.BLOCKED || state == State.WAITING)
				this.dataThread.interrupt();
		}
	}

	this.dataTasks = new LinkedBlockingQueue<DataTask>();
	this.dataWorker = new DataWorker(this, this.currentSession, this.dataTasks);
	this.dataThread = new Thread(dataWorker);
	this.dataThread.setName("Data Worker for " + this.currentSession);
	this.dataThread.start();
}
 

/** Returns an array list of debug information for all Java threads; useful for trying to diagnose the cause of odd behaviour.
 * 
 * @return An array list of debug information
 */
public static ArrayList<String> getThreadDebugData()
{
	ArrayList<String> strings = new ArrayList<String>();

	strings.add("------------------------------------------------------------");
	strings.add("Debugging information for Java virtual machine");
	ThreadInfo[] threads = ManagementFactory.getThreadMXBean().dumpAllThreads(true, true);
	for (ThreadInfo thread : threads)
	{
		if (thread.getThreadState() != State.WAITING)
		{
			strings.add("------------------------------------------------------------");
			strings.add(thread.getThreadName());
			strings.add("\tPID: " + thread.getThreadId() + " | Suspended: " + thread.isSuspended() + " | Native: " + thread.isInNative() + " | State: " + thread.getThreadState());
			if (thread.getLockedMonitors().length != 0)
			{
				strings.add("\tThread is waiting on monitor(s):");
				for (MonitorInfo monitor : thread.getLockedMonitors())
				{
					strings.add("\t\tLocked on:" + monitor.getLockedStackFrame());
				}
			}
			strings.add("\tStack trace:");

			StackTraceElement[] stack = thread.getStackTrace();
			for (int line = 0; line < stack.length; line++)
			{
				strings.add("\t\t" + stack[line].toString());
			}
		}
	}
	strings.add("------------------------------------------------------------");
	strings.add("End of debugging information");
	strings.add("------------------------------------------------------------");

	return strings;
}
 

public void resume() {
  if (_thread != null) {
    // Only force a resume when process is waiting for a notification
    if (_thread.getState() == State.WAITING) {
      synchronized (_tcx) {
        _tcx.notify();
      }
    } else if (_thread.getState() == State.TIMED_WAITING) {
      _tcx.waitUntilNotified(false);
    }
  }
}
 

public boolean isWaiting()
{
    if( _thread != null && _thread.getState() == State.WAITING )
    {
        return true;
    }
    return false;
}
 

private boolean checkActionIsPrepared() {
	if (WifiReceiver.getInstance().isConnected()
			&& ServiceManager.getInstance().isDmcOpen()) {
		if (Thread.currentThread().getState() == State.WAITING) {
			return false;
		}
		return true;
	} else {
		return false;
	}
}
 

public TimeoutError() {
	this.state = mainThread.getState();
	StackTraceElement[] trace = mainThread.getStackTrace();
	try {
		if ((state == State.WAITING) || (state == State.TIMED_WAITING)) {
			List<StackTraceElement> elements = new ArrayList<StackTraceElement>(Arrays.asList(trace));
			long ownerId = mainThread.getId();
			ThreadMXBean bean = ManagementFactory.getThreadMXBean();
			ThreadInfo threadInfo = null;
			long nextId = ownerId;
			while (nextId != -1) {
				threadInfo = bean.getThreadInfo(nextId, Integer.MAX_VALUE);
				if (threadInfo == null) {
					break; // the thread being blocked on has terminated
				}
				nextId = threadInfo.getLockOwnerId();
				if (nextId == ownerId) {
					break;
				}
				String threadName = threadInfo.getThreadName();
				elements.add(new StackTraceElement(TimeoutError.class.getCanonicalName(), "THREAD_" + threadName, "STACK$TRACE", 1));
				elements.addAll(Arrays.asList(threadInfo.getStackTrace()));
				if (nextId == -1) {
					break;
				}
			}
			trace = elements.toArray(trace);
		}
	} catch (Exception e) {
		LogUtil.error(e);
	}
	StackTraceElement[] newTrace = new StackTraceElement[trace.length+1];
	newTrace[0] = new StackTraceElement(TimeoutError.class.getCanonicalName(), "ESTIMATED", "STACK$TRACE", 1);
	System.arraycopy(trace, 0, newTrace, 1, trace.length);
	setStackTrace(trace);
}
 

public static void shutdownThreads() {
	if (persistenceThread != null) {
		worker.induceStop();
		State state = persistenceThread.getState();
		int tasks = worker.getNumTasks();
		if (tasks == 0 && (state == State.BLOCKED || state == State.WAITING))
			persistenceThread.interrupt();
		persistenceThread = null;
	}
}
 

public void requestImgDownload(String img_url, boolean fullScreen, TAImageDataHandler handler){
	try{
		Queue<doImgDownloadElem> msgs = imgDownThread.getpMsgs();
		doImgDownloadElem elem = new doImgDownloadElem(img_url, handler);
		elem.setFullScreen(fullScreen);
		msgs.add(elem);
		if(imgDownThread.getState() == State.WAITING){
			synchronized (msgs) {
				msgs.notify();
			}
		}
	}catch(final Exception ex){
		ex.printStackTrace();
	}
}
 

public boolean isWaiting() {
  if (_thread != null && _thread.getState() == State.WAITING) {
    return true;
  }
  return false;
}
 

@Override
public void run() {
    ExecutorService executorService = ThreadPool.pool;
    while (true) {
        Thread[] leastThreads = new Thread[Thread.activeCount()];
        int length = Thread.enumerate(leastThreads);

        boolean isAllWaiting = false;
        for (int i = 0; i < leastThreads.length; i++) {
            Thread thread = leastThreads[i];
            System.out.println("thread: " + thread.toString());
            System.out.println(thread.getState());

            System.out.println("thread.getState() == State.WAITING: "
                    + (thread.getState() == State.WAITING));

            if (thread.getName().startsWith("pool")) {
                if (thread.getState() == State.WAITING) {
                    isAllWaiting = true;
                    // thread.interrupt();
                    // System.out.println("等待线程结束：" + thread);
                } else {
                    isAllWaiting = false;
                }
            }
            // System.out.println(Thread.currentThread().getId());
        }
        if (isAllWaiting) {
            executorService.shutdownNow();
            if (executorService.isShutdown()) {
                System.out.println("pool.isShutdown() ================= "
                        + executorService.isShutdown());
                shutDowned();
                return;
            }
        }
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}