private void startNetwork() throws IOException { InetAddress addr = InetAddress.getLocalHost(); myHostAddress = addr.getHostAddress(); selfUser = new User(this.userName, this.myHostAddress, this.unicastPort); group = InetAddress.getByName(MULTICAST_ADDRESS); multicastSocket = new MulticastSocket(MULTICAST_PORT); // ? multicastSocket.setLoopbackMode(true); // listen for messages sent on this multicast socket: multicastListenThread = new Thread( new Runnable() { @Override public void run() { // this thread is started within the unicast listen thread, so the latter must // be running before we sent our multicast connect message System.out.println("multicast listen thread running"); try { multicastSocket.joinGroup(group); String message = "connect::name=" + userName + "::host=" + myHostAddress + "::port=" + unicastPort; DatagramPacket packet = new DatagramPacket( message.getBytes(), message.length(), group, MULTICAST_PORT); multicastSocket.send(packet); } catch (IOException e) { e.printStackTrace(); } byte[] inBuffer = new byte[1000]; DatagramPacket recv = new DatagramPacket(inBuffer, inBuffer.length); while (true) { try { multicastSocket.receive(recv); processPacket(recv, true); } catch (IOException e) { if (e instanceof SocketException && e.getMessage().equals("socket closed")) { System.out.println("inner thread terminating as socket now closed"); break; } e.printStackTrace(); break; } } } }); // listen for messages sent on unicast socket unicastListenThread = new Thread(this); unicastListenThread.setPriority(unicastListenThread.getPriority() + 1); unicastListenThread.start(); System.out.println( "unicastListenThread started at priority " + unicastListenThread.getPriority()); }
public static void main(String[] args) { System.out.println("main method"); Thread th = Thread.currentThread(); System.out.println("Original thread name: " + th.getName()); System.out.println("Original thread priority: " + th.getPriority()); th.setName("main-thread"); th.setPriority(7); System.out.println("Changed thread name: " + th.getName()); System.out.println("Changed thread priority: " + th.getPriority()); }
@Test public void testThreadDetails() { final AtomicReference<Thread> threadRef = new AtomicReference<Thread>(); SingleThreadEventExecutor executor = new SingleThreadEventExecutor(null, Executors.newCachedThreadPool(), false) { @Override protected void run() { threadRef.set(Thread.currentThread()); while (!confirmShutdown()) { Runnable task = takeTask(); if (task != null) { task.run(); } } } }; ThreadProperties threadProperties = executor.threadProperties(); Assert.assertSame(threadProperties, executor.threadProperties()); Thread thread = threadRef.get(); Assert.assertEquals(thread.getId(), threadProperties.id()); Assert.assertEquals(thread.getName(), threadProperties.name()); Assert.assertEquals(thread.getPriority(), threadProperties.priority()); Assert.assertEquals(thread.getState(), threadProperties.state()); Assert.assertEquals(thread.isAlive(), threadProperties.isAlive()); Assert.assertEquals(thread.isDaemon(), threadProperties.isDaemon()); Assert.assertEquals(thread.isInterrupted(), threadProperties.isInterrupted()); Assert.assertTrue(threadProperties.stackTrace().length > 0); executor.shutdownGracefully(); }
public Thread newThread(final Runnable r) { Thread t = new Thread(r, mTag + "-" + mCount.getAndIncrement()); if (t.getPriority() != Thread.MIN_PRIORITY) t.setPriority(Thread.MIN_PRIORITY); return t; }
// This method recursively visits all thread groups under `group'. public static void visit(ThreadGroup group, int level) { // Get threads in `group' int numThreads = group.activeCount(); Thread[] threads = new Thread[numThreads * 2]; numThreads = group.enumerate(threads, false); System.out.println("Threadgroup: " + group.getName()); // Enumerate each thread in `group' for (int i = 0; i < numThreads; i++) { // Get thread Thread thread = threads[i]; System.out.println( "Thread: " + thread.getName() + "(" + thread.getPriority() + ") has state " + thread.getState()); } // Get thread subgroups of `group' int numGroups = group.activeGroupCount(); ThreadGroup[] groups = new ThreadGroup[numGroups * 2]; numGroups = group.enumerate(groups, false); // Recursively visit each subgroup for (int i = 0; i < numGroups; i++) { visit(groups[i], level + 1); } }
public Thread newThread(Runnable r) { Thread t = new GSThread(group, r, namePrefix + threadNumber.get(), threadNumber.getAndIncrement()); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.MAX_PRIORITY) t.setPriority(Thread.MAX_PRIORITY); return t; }
private SimpleTimer() { final Thread thread = Thread.currentThread(); final int currentPrio = thread.getPriority(); try { // need this becase the timer's thread will inherit the priority on creation thread.setPriority(Thread.MIN_PRIORITY + 1); ourTimer = new Timer(THREAD_NAME, true); } finally { thread.setPriority(currentPrio); } }
@Override @TaskDescription("Background log writing") public void run() { final Thread currentThread = Thread.currentThread(); final int originalPriority = currentThread.getPriority(); currentThread.setPriority(threadPriority); try { runLogging(); } finally { // reset to previous value currentThread.setPriority(originalPriority); } };
@Override public void run() { Thread thread = new Thread("Cheating Essentials Main Thread"); thread.setName("Cheating Essentials Main Thread"); thread.setPriority(3); thread.start(); CELogAgent.logInfo(Strings.THREAD_NAME + " - Starting in " + Strings.MINECRAFT_VERSION + "..."); if (debugMode) { CELogAgent.logInfo("Thread priority: " + thread.getPriority()); CELogAgent.logInfo("Thread State (true / false): " + thread.isAlive()); CELogAgent.logInfo("Thread ID: " + thread.getId()); CELogAgent.logInfo("Thread Hashcode: " + thread.hashCode()); } CELogAgent.logInfo(Strings.THREAD_NAME + " Started " + thread.toString()); }
/** * Initialize a Thread. * * @param target the object whose run() method gets called * @param name the name of the new thread */ private void init(Runnable target, String name) { Thread parent = currentThread(); this.target = target; this.name = name.toCharArray(); this.priority = parent.getPriority(); setPriority(priority); }
private void showDefaultInfo(ThreadGroup grp) { TreeSet<Thread> threadSet = new TreeSet<Thread>( new Comparator<Thread>() { @Override public int compare(Thread t1, Thread t2) { return Long.valueOf(t1.getId()).compareTo(t2.getId()); } }); findThreads(grp, threadSet); PrintWriter out = getOutput().getPrintWriter(); for (final Thread thread : threadSet) { VmThread vmThread = AccessController.doPrivileged( new PrivilegedAction<VmThread>() { public VmThread run() { return ThreadHelper.getVmThread(thread); } }); out.println( " " + thread.getId() + SEPARATOR + thread.getName() + SEPARATOR + thread.getPriority() + SEPARATOR + vmThread.getThreadStateName()); } }
private static void writeThreadInfo(PrintWriter pw, Thread thread, State state) { pw.printf("Main: Id %d - %s\n", thread.getId(), thread.getName()); pw.printf("Main:Prioity: %d\n", thread.getPriority()); pw.printf("Main:Old state:%s\n", state); pw.printf("Main:New state:%s\n", thread.getState()); pw.printf("Main:***********************************\n"); }
public static void main(String[] args) { Thread thread = Thread.currentThread(); System.out.println("Thread: " + thread); System.out.println("Thread Id: " + thread.getId()); System.out.println("Thread Name: " + thread.getName()); System.out.println("Thread Group: " + thread.getThreadGroup()); System.out.println("Thread Priority: " + thread.getPriority()); }
public static String getThreadSignature() { Thread t = Thread.currentThread(); long l = t.getId(); String name = t.getName(); long p = t.getPriority(); String gname = t.getThreadGroup().getName(); return (name + ":(id)" + l + ":(priority)" + p + ":(group)" + gname); }
public void drop(DropTargetDropEvent dtde) { dtde.acceptDrop(DnDConstants.ACTION_COPY); DataFlavor[] flavors = null; try { Transferable t = dtde.getTransferable(); iterator = null; flavors = t.getTransferDataFlavors(); if (IJ.debugMode) IJ.log("DragAndDrop.drop: " + flavors.length + " flavors"); for (int i = 0; i < flavors.length; i++) { if (IJ.debugMode) IJ.log(" flavor[" + i + "]: " + flavors[i].getMimeType()); if (flavors[i].isFlavorJavaFileListType()) { Object data = t.getTransferData(DataFlavor.javaFileListFlavor); iterator = ((List) data).iterator(); break; } else if (flavors[i].isFlavorTextType()) { Object ob = t.getTransferData(flavors[i]); if (!(ob instanceof String)) continue; String s = ob.toString().trim(); if (IJ.isLinux() && s.length() > 1 && (int) s.charAt(1) == 0) s = fixLinuxString(s); ArrayList list = new ArrayList(); if (s.indexOf("href=\"") != -1 || s.indexOf("src=\"") != -1) { s = parseHTML(s); if (IJ.debugMode) IJ.log(" url: " + s); list.add(s); this.iterator = list.iterator(); break; } BufferedReader br = new BufferedReader(new StringReader(s)); String tmp; while (null != (tmp = br.readLine())) { tmp = java.net.URLDecoder.decode(tmp.replaceAll("\\+", "%2b"), "UTF-8"); if (tmp.startsWith("file://")) tmp = tmp.substring(7); if (IJ.debugMode) IJ.log(" content: " + tmp); if (tmp.startsWith("http://")) list.add(s); else list.add(new File(tmp)); } this.iterator = list.iterator(); break; } } if (iterator != null) { Thread thread = new Thread(this, "DrawAndDrop"); thread.setPriority(Math.max(thread.getPriority() - 1, Thread.MIN_PRIORITY)); thread.start(); } } catch (Exception e) { dtde.dropComplete(false); return; } dtde.dropComplete(true); if (flavors == null || flavors.length == 0) { if (IJ.isMacOSX()) IJ.error( "First drag and drop ignored. Please try again. You can avoid this\n" + "problem by dragging to the toolbar instead of the status bar."); else IJ.error("Drag and drop failed"); } }
public Thread newThread(Runnable r) { Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement()); t.setDaemon(true); if (t.getPriority() != Thread.NORM_PRIORITY) { t.setPriority(Thread.NORM_PRIORITY); } return t; }
public void update() { Thread th = Thread.currentThread(); for (int i = 11; i <= 20; i++) { System.out.println("Update : " + i + "\t" + th.getName() + "\t" + th.getPriority()); try { Thread.sleep(1000); } catch (Exception e) { e.printStackTrace(); } } }
public Thread newThread(Runnable r) { String name = threadName + "-" + threadNum.getAndIncrement(); Thread t = new Thread(r, name); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; }
@Override public Thread newThread(Runnable r) { Thread t = new Thread(null, r, "hj", 0); if (t.isDaemon()) { t.setDaemon(false); } if (t.getPriority() != Thread.NORM_PRIORITY) { t.setPriority(Thread.NORM_PRIORITY); } return t; }
@Override public Thread newThread(Runnable r) { Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0); if (t.isDaemon()) t.setDaemon(false); // I can't really see that we want non-daemon threads... // Seems we might get problem with daemon-threads?? Does this mess up join after invoke?? // t.setDaemon(true); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; }
public static void startRDPServer() { if (rdpServerStarted) return; rdpServerStarted = true; rdpServerThread = new Thread(rdpServer, "RDPServer"); retryThread = new Thread(new RetryThread(), "RDPRetry"); packetCallbackThread = new Thread(new PacketCallbackThread(), "RDPCallback"); if (Log.loggingNet) Log.net("static - starting rdpserver thread"); try { selector = Selector.open(); } catch (Exception e) { Log.exception("RDPServer caught exception opening selector", e); System.exit(1); } rdpServerThread.setPriority(rdpServerThread.getPriority() + 2); if (Log.loggingDebug) Log.debug( "RDPServer: starting rdpServerThread with priority " + rdpServerThread.getPriority()); rdpServerThread.start(); retryThread.start(); packetCallbackThread.start(); }
/** * Traverse the ThreadGroups threads and its child ThreadGroups printing information for each * thread found. If 'threadName' is non-null, only print information for the thread that matches * the name. * * @param grp the ThreadGroup to traverse * @param out the destination for output * @param threadName if non-null, only display this thread. */ private void showThreads(ThreadGroup grp, PrintWriter out, String threadName) { if (threadName == null) { out.println(GROUP + grp.getName()); } final int max = grp.activeCount() * 2; final Thread[] ts = new Thread[max]; grp.enumerate(ts); for (int i = 0; i < max; i++) { final Thread t = ts[i]; if (t != null) { if ((threadName == null) || threadName.equals(t.getName())) { VmThread vmThread = AccessController.doPrivileged( new PrivilegedAction<VmThread>() { public VmThread run() { return ThreadHelper.getVmThread(t); } }); out.println( SLASH_T + t.getId() + SEPARATOR + t.getName() + SEPARATOR + t.getPriority() + SEPARATOR + vmThread.getThreadStateName()); if (threadName != null) { final Object[] trace = VmThread.getStackTrace(vmThread); final int traceLen = trace.length; out.println(SLASH_T + SLASH_T + TRACE); for (int k = 0; k < traceLen; k++) { out.println(SLASH_T + SLASH_T + trace[k]); } return; } } } } final int gmax = grp.activeGroupCount() * 2; final ThreadGroup[] tgs = new ThreadGroup[gmax]; grp.enumerate(tgs); for (int i = 0; i < gmax; i++) { final ThreadGroup tg = tgs[i]; if (tg != null) { showThreads(tg, out, threadName); } } }
@Override public void query(QueryContext context, String queryString, MetadataCallback callback) { ThreadMXBean bean = ManagementFactory.getThreadMXBean(); ArrayList<ThreadCpuUsage> usages = new ArrayList<ThreadCpuUsage>(); for (long tid : bean.getAllThreadIds()) { long time = bean.getThreadCpuTime(tid); usages.add(new ThreadCpuUsage(tid, time)); } try { Thread.sleep(1000); } catch (InterruptedException e) { } Map<Thread, StackTraceElement[]> stacks = Thread.getAllStackTraces(); for (long tid : bean.getAllThreadIds()) { ThreadCpuUsage usage = find(usages, tid); if (usage != null) usage.secondTime = bean.getThreadCpuTime(tid); } Collections.sort(usages); for (ThreadCpuUsage usage : usages) { long elapsed = usage.secondTime - usage.firstTime; // remove just created thread or sleeping threads (noisy) if (elapsed <= 0) continue; StringBuilder sb = new StringBuilder(); Thread t = findThread(stacks, usage.tid); if (t == null) continue; StackTraceElement[] stack = findStack(stacks, usage.tid); for (StackTraceElement el : stack) { sb.append( String.format( "%s.%s %s\n", el.getClassName(), el.getMethodName(), getFileAndLineNumber(el))); } Map<String, Object> m = new HashMap<String, Object>(); m.put("tid", t.getId()); m.put("name", t.getName()); m.put("state", t.getState().toString()); m.put("priority", t.getPriority()); m.put("usage", elapsed); m.put("stacktrace", sb.toString()); callback.onPush(new Row(m)); } }
public Thread newThread(Runnable r) { if (LOG.isLoggable(Level.FINE)) { LOG.fine("creating new thread"); } Thread t = new Thread(r, namePrefix + threadNumber.getAndIncrement()); t.setDaemon(isDaemon); if (t.getPriority() != Thread.NORM_PRIORITY) { t.setPriority(Thread.NORM_PRIORITY); } return t; }
public static void main(String[] args) { Thread ct = Thread.currentThread(); System.out.println(ct.getName()); System.out.println(ct.getStackTrace()); System.out.println(ct.getPriority()); try { ct.sleep(2000); System.out.println(ct.getState()); } catch (InterruptedException e) { System.out.println("поток поломался"); } }
/** * Logs the exception with information about which thread the exception happened in, and notifies * listeners. * * @param thread The thread that got the exception. * @param throwable The exception the thread got. */ @Override public void uncaughtException(final Thread thread, final Throwable throwable) { LOG.log( Level.SEVERE, "UncaughtException in thread: " + thread.getName() + " (id " + thread.getId() + ", priority " + thread.getPriority() + ")", throwable); for (final UncaughtExceptionListener listener : listeners) { listener.uncaughtException(thread, throwable); } }
/** Print diagnostic information about currently running threads at warn level. */ public void threadGroupList() { Thread[] threads = new Thread[_threads.activeCount()]; _threads.enumerate(threads); for (Thread thread : threads) { LOGGER.warn( "Thread: {} [{}{}{}] ({}) {}", thread.getName(), (thread.isAlive() ? "A" : "-"), (thread.isDaemon() ? "D" : "-"), (thread.isInterrupted() ? "I" : "-"), thread.getPriority(), thread.getState()); for (StackTraceElement s : thread.getStackTrace()) { LOGGER.warn(" {}", s); } } }
protected void printFullThreadDump() { StringBundler sb = new StringBundler(); sb.append("Full thread dump "); sb.append(System.getProperty("java.vm.name")); sb.append(" "); sb.append(System.getProperty("java.vm.version")); sb.append("\n\n"); Map<Thread, StackTraceElement[]> stackTraces = Thread.getAllStackTraces(); for (Map.Entry<Thread, StackTraceElement[]> entry : stackTraces.entrySet()) { Thread thread = entry.getKey(); StackTraceElement[] elements = entry.getValue(); sb.append("\""); sb.append(thread.getName()); sb.append("\""); if (thread.getThreadGroup() != null) { sb.append(" ("); sb.append(thread.getThreadGroup().getName()); sb.append(")"); } sb.append(", priority="); sb.append(thread.getPriority()); sb.append(", id="); sb.append(thread.getId()); sb.append(", state="); sb.append(thread.getState()); sb.append("\n"); for (int i = 0; i < elements.length; i++) { sb.append("\t"); sb.append(elements[i]); sb.append("\n"); } sb.append("\n"); } System.out.println(sb); }
protected void startGameCanvasRunnableInterface() throws Exception { // LogUtil.put(LogFactory.getInstance(CommonStrings.getInstance().START, this, // "startGameCanvasRunnableInterface")); thread = thread = ThreadFactoryUtil.getInstance().getInstance(this.allbinaryGameCanvasRunnableInterface); LogUtil.put( LogFactory.getInstance( "Thread Priority: " + thread.getPriority(), this, "startGameCanvasRunnableInterface")); // canvasThread.setPriority(Thread.NORM_PRIORITY + 2); // thread.setPriority(Thread.MAX_PRIORITY); this.allbinaryGameCanvasRunnableInterface.setThread(thread); thread.start(); }
@Override public void run() { System.out.println("unicast listen thread running"); byte[] data = new byte[100]; DatagramPacket packet = new DatagramPacket(data, data.length); try { multicastListenThread.start(); System.out.println( "multicastListenThread started at priority " + multicastListenThread.getPriority()); unicastSocket = new DatagramSocket(unicastPort); while (true) { unicastSocket.receive(packet); processPacket(packet, false); } } catch (IOException e) { e.printStackTrace(); } }