test/924-threads/src/art/Test924.java - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package art;

 import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Function;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.time.Instant;

 public class Test924 {
   public static void run() throws Exception {
     // Run the test on its own thread, so we have a known state for the "current" thread.
     Thread t = new Thread("TestThread") {
       @Override
       public void run() {
         try {
           doTest();
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     };
     t.start();
     t.join();
   }

   private static void doTest() throws Exception {
     Thread t1 = Thread.currentThread();
     Thread t2 = getCurrentThread();

     // Need to adjust priority, as on-device this may be unexpected (and we prefer not
     // to special-case this.)
     t1.setPriority(5);

     if (t1 != t2) {
       throw new RuntimeException("Expected " + t1 + " but got " + t2);
     }
     System.out.println("currentThread OK");

     printThreadInfo(t1);
     printThreadInfo(null);

     Thread t3 = new Thread("Daemon Thread");
     t3.setDaemon(true);
     // Do not start this thread, yet.
     printThreadInfo(t3);
     // Start, and wait for it to die.
     t3.start();
     t3.join();
     Thread.sleep(500);  // Wait a little bit.
     // Thread has died, check that we can still get info.
     printThreadInfo(t3);

     // Try a subclass of thread.
     Thread t4 = new Thread("Subclass") {
     };
     printThreadInfo(t4);

     doCurrentThreadStateTests();
     doStateTests(Thread::new);
     doStateTests(ExtThread::new);

     doAllThreadsTests();

     doTLSTests();

     doTestEvents();
   }

   private static final class ExtThread extends Thread {
     public ExtThread(Runnable r) { super(r); }
   }

   private static class Holder {
     volatile boolean flag = false;
   }

   private static void doCurrentThreadStateTests() throws Exception {
     System.out.println(Integer.toHexString(getThreadState(null)));
     System.out.println(Integer.toHexString(getThreadState(Thread.currentThread())));
   }

   private static void doStateTests(Function<Runnable, Thread> mkThread) throws Exception {
     final CountDownLatch cdl1 = new CountDownLatch(1);
     final CountDownLatch cdl2 = new CountDownLatch(1);
     final CountDownLatch cdl3_1 = new CountDownLatch(1);
     final CountDownLatch cdl3_2 = new CountDownLatch(1);
     final CountDownLatch cdl4 = new CountDownLatch(1);
     final CountDownLatch cdl5 = new CountDownLatch(1);
     final Holder h = new Holder();
     final long ALMOST_INFINITE = 100000000;  // 1.1 days!
     final NativeWaiter w = new NativeWaiter();
     Runnable r = new Runnable() {
       @Override
       public void run() {
         try {
           cdl1.countDown();
           synchronized(cdl1) {
             cdl1.wait();
           }

           cdl2.countDown();
           synchronized(cdl2) {
             cdl2.wait(ALMOST_INFINITE);
           }

           cdl3_1.await();
           cdl3_2.countDown();
           synchronized(cdl3_2) {
             // Nothing, just wanted to block on cdl3.
           }

           cdl4.countDown();
           try {
             Thread.sleep(ALMOST_INFINITE);
           } catch (InterruptedException e) { }

           cdl5.countDown();
           while (!h.flag) {
             // Busy-loop.
           }

           nativeLoop(w.struct);
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     };

     Thread t = mkThread.apply(r);
     System.out.println("Thread type is " + t.getClass());
     printThreadState(t);
     t.start();

     // Waiting.
     cdl1.await();
     // This is super inconsistent so just wait for the desired state for up to 5 minutes then give
     // up and continue
     final int WAITING_INDEF = 0x191;
     waitForState(t, WAITING_INDEF);
     synchronized(cdl1) {
       cdl1.notifyAll();
     }

     // Timed waiting.
     cdl2.await();
     // This is super inconsistent so just wait for the desired state for up to 5 minutes then give
     // up and continue
     final int WAITING_TIMED = 0x1a1;
     waitForState(t, WAITING_TIMED);
     synchronized(cdl2) {
       cdl2.notifyAll();
     }

     // Blocked on monitor.
     synchronized(cdl3_2) {
       cdl3_1.countDown();
       cdl3_2.await();
       // While the latch improves the chances to make good progress, scheduling might still be
       // messy. Wait till we get the right Java-side Thread state.
       do {
         Thread.yield();
       } while (t.getState() != Thread.State.BLOCKED);
       // Since internal thread suspension (For GC or other cases) can happen at any time and changes
       // the thread state we just have it print the majority thread state across 11 calls over 55
       // milliseconds.
       printMajorityThreadState(t, 11, 5);
     }

     // Sleeping.
     cdl4.await();
     // This is super inconsistent so just wait for the desired state for up to 5 minutes then give
     // up and continue
     final int WAITING_SLEEP = 0xe1;
     waitForState(t, WAITING_SLEEP);
     t.interrupt();

     // Running.
     cdl5.await();
     Thread.yield();
     Thread.sleep(1000);
     printThreadState(t);
     h.flag = true;

     // Native
     w.waitForNative();
     printThreadState(t);
     w.finish();

     // Dying.
     t.join();
     Thread.yield();
     Thread.sleep(1000);

     printThreadState(t);
   }

   private static void waitForState(Thread t, int desired) throws Exception {
     Thread.yield();
     Thread.sleep(1000);
     // This is super inconsistent so just wait for the desired state for up to 5 minutes then give
     // up and continue
     int state;
     Instant deadline = Instant.now().plusSeconds(60 * 5);
     while ((state = getThreadState(t)) != desired && deadline.isAfter(Instant.now())) {
       Thread.yield();
       Thread.sleep(100);
       Thread.yield();
     }
     printThreadState(state);
   }

   private static void doAllThreadsTests() {
     Thread[] threads = getAllThreads();
     List<Thread> threadList = new ArrayList<>(Arrays.asList(threads));

     // Filter out JIT thread. It may or may not be there depending on configuration.
     Iterator<Thread> it = threadList.iterator();
     while (it.hasNext()) {
       Thread t = it.next();
       if (t.getName().startsWith("Jit thread pool worker")) {
         it.remove();
         break;
       }
     }

     Collections.sort(threadList, THREAD_COMP);

     List<Thread> expectedList = new ArrayList<>();
     Set<Thread> threadsFromTraces = Thread.getAllStackTraces().keySet();

     expectedList.add(findThreadByName(threadsFromTraces, "FinalizerDaemon"));
     expectedList.add(findThreadByName(threadsFromTraces, "FinalizerWatchdogDaemon"));
     expectedList.add(findThreadByName(threadsFromTraces, "HeapTaskDaemon"));
     expectedList.add(findThreadByName(threadsFromTraces, "ReferenceQueueDaemon"));
     // We can't get the signal catcher through getAllStackTraces. So ignore it.
     // expectedList.add(findThreadByName(threadsFromTraces, "Signal Catcher"));
     expectedList.add(findThreadByName(threadsFromTraces, "TestThread"));
     expectedList.add(findThreadByName(threadsFromTraces, "main"));

     if (!threadList.containsAll(expectedList)) {
       throw new RuntimeException("Expected " + expectedList + " as subset, got " + threadList);
     }
     System.out.println(expectedList);
   }

   private static Thread findThreadByName(Set<Thread> threads, String name) {
     for (Thread t : threads) {
         if (t.getName().equals(name)) {
             return t;
         }
     }
     throw new RuntimeException("Did not find thread " + name + ": " + threads);
   }

   private static void doTLSTests() throws Exception {
     doTLSNonLiveTests();
     doTLSLiveTests();
   }

   private static void doTLSNonLiveTests() throws Exception {
     Thread t = new Thread();
     try {
       setTLS(t, 1);
       System.out.println("Expected failure setting TLS for non-live thread");
     } catch (Exception e) {
       System.out.println(e.getMessage());
     }
     t.start();
     t.join();
     try {
       setTLS(t, 1);
       System.out.println("Expected failure setting TLS for non-live thread");
     } catch (Exception e) {
       System.out.println(e.getMessage());
     }
   }

   private static void doTLSLiveTests() throws Exception {
     setTLS(Thread.currentThread(), 1);

     long l = getTLS(Thread.currentThread());
     if (l != 1) {
       throw new RuntimeException("Unexpected TLS value: " + l);
     };

     final CountDownLatch cdl1 = new CountDownLatch(1);
     final CountDownLatch cdl2 = new CountDownLatch(1);

     Runnable r = new Runnable() {
       @Override
       public void run() {
         try {
           cdl1.countDown();
           cdl2.await();
           setTLS(Thread.currentThread(), 2);
           if (getTLS(Thread.currentThread()) != 2) {
             throw new RuntimeException("Different thread issue");
           }
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     };

     Thread t = new Thread(r);
     t.start();
     cdl1.await();
     setTLS(Thread.currentThread(), 1);
     cdl2.countDown();

     t.join();
     if (getTLS(Thread.currentThread()) != 1) {
       throw new RuntimeException("Got clobbered");
     }
   }

   private static List<String> filterForThread(Object[] thread_messages, String thread_name) {
     List<String> messageListForThread = new ArrayList<String>();

     for (int i = 0; i < thread_messages.length; i++) {
       String message = (String)thread_messages[i];
       if (message.startsWith("Thread(" + thread_name + ")")) {
         messageListForThread.add(message);
       }
     }

     return messageListForThread;
   }

   private static void doTestEvents() throws Exception {
     enableThreadEvents(true);

     final CountDownLatch cdl1 = new CountDownLatch(1);
     final CountDownLatch cdl2 = new CountDownLatch(1);

     Runnable r = new Runnable() {
       @Override
       public void run() {
         try {
           cdl1.countDown();
           cdl2.await();
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     };
     String thread_name = "EventTestThread";
     Thread t = new Thread(r, thread_name);

     System.out.println("Constructed thread");
     Thread.yield();
     Thread.sleep(100);

     // Check that there are no events related to EventTestThread that we just created.
     System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

     t.start();
     cdl1.await();

     System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

     cdl2.countDown();
     t.join();
     System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

     System.out.println("Thread joined");

     enableThreadEvents(false);
   }

   private final static Comparator<Thread> THREAD_COMP = new Comparator<Thread>() {
     public int compare(Thread o1, Thread o2) {
       return o1.getName().compareTo(o2.getName());
     }
   };

   private final static Map<Integer, String> STATE_NAMES = new HashMap<Integer, String>();
   private final static List<Integer> STATE_KEYS = new ArrayList<Integer>();
   static {
     STATE_NAMES.put(0x1, "ALIVE");
     STATE_NAMES.put(0x2, "TERMINATED");
     STATE_NAMES.put(0x4, "RUNNABLE");
     STATE_NAMES.put(0x400, "BLOCKED_ON_MONITOR_ENTER");
     STATE_NAMES.put(0x80, "WAITING");
     STATE_NAMES.put(0x10, "WAITING_INDEFINITELY");
     STATE_NAMES.put(0x20, "WAITING_WITH_TIMEOUT");
     STATE_NAMES.put(0x40, "SLEEPING");
     STATE_NAMES.put(0x100, "IN_OBJECT_WAIT");
     STATE_NAMES.put(0x200, "PARKED");
     STATE_NAMES.put(0x100000, "SUSPENDED");
     STATE_NAMES.put(0x200000, "INTERRUPTED");
     STATE_NAMES.put(0x400000, "IN_NATIVE");
     STATE_KEYS.addAll(STATE_NAMES.keySet());
     Collections.sort(STATE_KEYS);
   }

   // Call getThreadState 'votes' times waiting 'wait' millis between calls and print the most common
   // result.
   private static void printMajorityThreadState(Thread t, int votes, int wait) throws Exception {
     Map<Integer, Integer> states = new HashMap<>();
     for (int i = 0; i < votes; i++) {
       int cur_state = getThreadState(t);
       states.put(cur_state, states.getOrDefault(cur_state, 0) + 1);
       Thread.sleep(wait);  // Wait a little bit.
     }
     int best_state = -1;
     int highest_count = 0;
     for (Map.Entry<Integer, Integer> e : states.entrySet()) {
       if (e.getValue() > highest_count) {
         highest_count = e.getValue();
         best_state = e.getKey();
       }
     }
     printThreadState(best_state);
   }

   private static void printThreadState(Thread t) {
     printThreadState(getThreadState(t));
   }

   private static void printThreadState(int state) {
     StringBuilder sb = new StringBuilder();

     for (Integer i : STATE_KEYS) {
       if ((state & i) != 0) {
         if (sb.length()>0) {
           sb.append('|');
         }
         sb.append(STATE_NAMES.get(i));
       }
     }

     if (sb.length() == 0) {
       sb.append("NEW");
     }

     System.out.println(Integer.toHexString(state) + " = " + sb.toString());
   }

   private static void printThreadInfo(Thread t) {
     Object[] threadInfo = getThreadInfo(t);
     if (threadInfo == null || threadInfo.length != 5) {
       System.out.println(Arrays.toString(threadInfo));
       throw new RuntimeException("threadInfo length wrong");
     }

     System.out.println(threadInfo[0]);  // Name
     System.out.println(threadInfo[1]);  // Priority
     System.out.println(threadInfo[2]);  // Daemon
     System.out.println(threadInfo[3]);  // Threadgroup
     System.out.println(threadInfo[4] == null ? "null" : threadInfo[4].getClass());  // Context CL.
   }

   public static final class NativeWaiter {
     public long struct;
     public NativeWaiter() {
       struct = nativeWaiterStructAlloc();
     }
     public void waitForNative() {
       if (struct == 0l) {
         throw new Error("Already resumed from native!");
       }
       nativeWaiterStructWaitForNative(struct);
     }
     public void finish() {
       if (struct == 0l) {
         throw new Error("Already resumed from native!");
       }
       nativeWaiterStructFinish(struct);
       struct = 0;
     }
   }

   private static native long nativeWaiterStructAlloc();
   private static native void nativeWaiterStructWaitForNative(long struct);
   private static native void nativeWaiterStructFinish(long struct);
   private static native void nativeLoop(long w);

   private static native Thread getCurrentThread();
   private static native Object[] getThreadInfo(Thread t);
   private static native int getThreadState(Thread t);
   private static native Thread[] getAllThreads();
   private static native void setTLS(Thread t, long l);
   private static native long getTLS(Thread t);
   private static native void enableThreadEvents(boolean b);
   private static native String[] getThreadEventMessages();
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package art;

	import java.util.Arrays;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.concurrent.CountDownLatch;
	import java.util.function.Function;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.time.Instant;

	public class Test924 {
	public static void run() throws Exception {
	// Run the test on its own thread, so we have a known state for the "current" thread.
	Thread t = new Thread("TestThread") {
	@Override
	public void run() {
	try {
	doTest();
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	};
	t.start();
	t.join();
	}

	private static void doTest() throws Exception {
	Thread t1 = Thread.currentThread();
	Thread t2 = getCurrentThread();

	// Need to adjust priority, as on-device this may be unexpected (and we prefer not
	// to special-case this.)
	t1.setPriority(5);

	if (t1 != t2) {
	throw new RuntimeException("Expected " + t1 + " but got " + t2);
	}
	System.out.println("currentThread OK");

	printThreadInfo(t1);
	printThreadInfo(null);

	Thread t3 = new Thread("Daemon Thread");
	t3.setDaemon(true);
	// Do not start this thread, yet.
	printThreadInfo(t3);
	// Start, and wait for it to die.
	t3.start();
	t3.join();
	Thread.sleep(500); // Wait a little bit.
	// Thread has died, check that we can still get info.
	printThreadInfo(t3);

	// Try a subclass of thread.
	Thread t4 = new Thread("Subclass") {
	};
	printThreadInfo(t4);

	doCurrentThreadStateTests();
	doStateTests(Thread::new);
	doStateTests(ExtThread::new);

	doAllThreadsTests();

	doTLSTests();

	doTestEvents();
	}

	private static final class ExtThread extends Thread {
	public ExtThread(Runnable r) { super(r); }
	}

	private static class Holder {
	volatile boolean flag = false;
	}

	private static void doCurrentThreadStateTests() throws Exception {
	System.out.println(Integer.toHexString(getThreadState(null)));
	System.out.println(Integer.toHexString(getThreadState(Thread.currentThread())));
	}

	private static void doStateTests(Function<Runnable, Thread> mkThread) throws Exception {
	final CountDownLatch cdl1 = new CountDownLatch(1);
	final CountDownLatch cdl2 = new CountDownLatch(1);
	final CountDownLatch cdl3_1 = new CountDownLatch(1);
	final CountDownLatch cdl3_2 = new CountDownLatch(1);
	final CountDownLatch cdl4 = new CountDownLatch(1);
	final CountDownLatch cdl5 = new CountDownLatch(1);
	final Holder h = new Holder();
	final long ALMOST_INFINITE = 100000000; // 1.1 days!
	final NativeWaiter w = new NativeWaiter();
	Runnable r = new Runnable() {
	@Override
	public void run() {
	try {
	cdl1.countDown();
	synchronized(cdl1) {
	cdl1.wait();
	}

	cdl2.countDown();
	synchronized(cdl2) {
	cdl2.wait(ALMOST_INFINITE);
	}

	cdl3_1.await();
	cdl3_2.countDown();
	synchronized(cdl3_2) {
	// Nothing, just wanted to block on cdl3.
	}

	cdl4.countDown();
	try {
	Thread.sleep(ALMOST_INFINITE);
	} catch (InterruptedException e) { }

	cdl5.countDown();
	while (!h.flag) {
	// Busy-loop.
	}

	nativeLoop(w.struct);
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	};

	Thread t = mkThread.apply(r);
	System.out.println("Thread type is " + t.getClass());
	printThreadState(t);
	t.start();

	// Waiting.
	cdl1.await();
	// This is super inconsistent so just wait for the desired state for up to 5 minutes then give
	// up and continue
	final int WAITING_INDEF = 0x191;
	waitForState(t, WAITING_INDEF);
	synchronized(cdl1) {
	cdl1.notifyAll();
	}

	// Timed waiting.
	cdl2.await();
	// This is super inconsistent so just wait for the desired state for up to 5 minutes then give
	// up and continue
	final int WAITING_TIMED = 0x1a1;
	waitForState(t, WAITING_TIMED);
	synchronized(cdl2) {
	cdl2.notifyAll();
	}

	// Blocked on monitor.
	synchronized(cdl3_2) {
	cdl3_1.countDown();
	cdl3_2.await();
	// While the latch improves the chances to make good progress, scheduling might still be
	// messy. Wait till we get the right Java-side Thread state.
	do {
	Thread.yield();
	} while (t.getState() != Thread.State.BLOCKED);
	// Since internal thread suspension (For GC or other cases) can happen at any time and changes
	// the thread state we just have it print the majority thread state across 11 calls over 55
	// milliseconds.
	printMajorityThreadState(t, 11, 5);
	}

	// Sleeping.
	cdl4.await();
	// This is super inconsistent so just wait for the desired state for up to 5 minutes then give
	// up and continue
	final int WAITING_SLEEP = 0xe1;
	waitForState(t, WAITING_SLEEP);
	t.interrupt();

	// Running.
	cdl5.await();
	Thread.yield();
	Thread.sleep(1000);
	printThreadState(t);
	h.flag = true;

	// Native
	w.waitForNative();
	printThreadState(t);
	w.finish();

	// Dying.
	t.join();
	Thread.yield();
	Thread.sleep(1000);

	printThreadState(t);
	}

	private static void waitForState(Thread t, int desired) throws Exception {
	Thread.yield();
	Thread.sleep(1000);
	// This is super inconsistent so just wait for the desired state for up to 5 minutes then give
	// up and continue
	int state;
	Instant deadline = Instant.now().plusSeconds(60 * 5);
	while ((state = getThreadState(t)) != desired && deadline.isAfter(Instant.now())) {
	Thread.yield();
	Thread.sleep(100);
	Thread.yield();
	}
	printThreadState(state);
	}

	private static void doAllThreadsTests() {
	Thread[] threads = getAllThreads();
	List<Thread> threadList = new ArrayList<>(Arrays.asList(threads));

	// Filter out JIT thread. It may or may not be there depending on configuration.
	Iterator<Thread> it = threadList.iterator();
	while (it.hasNext()) {
	Thread t = it.next();
	if (t.getName().startsWith("Jit thread pool worker")) {
	it.remove();
	break;
	}
	}

	Collections.sort(threadList, THREAD_COMP);

	List<Thread> expectedList = new ArrayList<>();
	Set<Thread> threadsFromTraces = Thread.getAllStackTraces().keySet();

	expectedList.add(findThreadByName(threadsFromTraces, "FinalizerDaemon"));
	expectedList.add(findThreadByName(threadsFromTraces, "FinalizerWatchdogDaemon"));
	expectedList.add(findThreadByName(threadsFromTraces, "HeapTaskDaemon"));
	expectedList.add(findThreadByName(threadsFromTraces, "ReferenceQueueDaemon"));
	// We can't get the signal catcher through getAllStackTraces. So ignore it.
	// expectedList.add(findThreadByName(threadsFromTraces, "Signal Catcher"));
	expectedList.add(findThreadByName(threadsFromTraces, "TestThread"));
	expectedList.add(findThreadByName(threadsFromTraces, "main"));

	if (!threadList.containsAll(expectedList)) {
	throw new RuntimeException("Expected " + expectedList + " as subset, got " + threadList);
	}
	System.out.println(expectedList);
	}

	private static Thread findThreadByName(Set<Thread> threads, String name) {
	for (Thread t : threads) {
	if (t.getName().equals(name)) {
	return t;
	}
	}
	throw new RuntimeException("Did not find thread " + name + ": " + threads);
	}

	private static void doTLSTests() throws Exception {
	doTLSNonLiveTests();
	doTLSLiveTests();
	}

	private static void doTLSNonLiveTests() throws Exception {
	Thread t = new Thread();
	try {
	setTLS(t, 1);
	System.out.println("Expected failure setting TLS for non-live thread");
	} catch (Exception e) {
	System.out.println(e.getMessage());
	}
	t.start();
	t.join();
	try {
	setTLS(t, 1);
	System.out.println("Expected failure setting TLS for non-live thread");
	} catch (Exception e) {
	System.out.println(e.getMessage());
	}
	}

	private static void doTLSLiveTests() throws Exception {
	setTLS(Thread.currentThread(), 1);

	long l = getTLS(Thread.currentThread());
	if (l != 1) {
	throw new RuntimeException("Unexpected TLS value: " + l);
	};

	final CountDownLatch cdl1 = new CountDownLatch(1);
	final CountDownLatch cdl2 = new CountDownLatch(1);

	Runnable r = new Runnable() {
	@Override
	public void run() {
	try {
	cdl1.countDown();
	cdl2.await();
	setTLS(Thread.currentThread(), 2);
	if (getTLS(Thread.currentThread()) != 2) {
	throw new RuntimeException("Different thread issue");
	}
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	};

	Thread t = new Thread(r);
	t.start();
	cdl1.await();
	setTLS(Thread.currentThread(), 1);
	cdl2.countDown();

	t.join();
	if (getTLS(Thread.currentThread()) != 1) {
	throw new RuntimeException("Got clobbered");
	}
	}

	private static List<String> filterForThread(Object[] thread_messages, String thread_name) {
	List<String> messageListForThread = new ArrayList<String>();

	for (int i = 0; i < thread_messages.length; i++) {
	String message = (String)thread_messages[i];
	if (message.startsWith("Thread(" + thread_name + ")")) {
	messageListForThread.add(message);
	}
	}

	return messageListForThread;
	}

	private static void doTestEvents() throws Exception {
	enableThreadEvents(true);

	final CountDownLatch cdl1 = new CountDownLatch(1);
	final CountDownLatch cdl2 = new CountDownLatch(1);

	Runnable r = new Runnable() {
	@Override
	public void run() {
	try {
	cdl1.countDown();
	cdl2.await();
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}
	};
	String thread_name = "EventTestThread";
	Thread t = new Thread(r, thread_name);

	System.out.println("Constructed thread");
	Thread.yield();
	Thread.sleep(100);

	// Check that there are no events related to EventTestThread that we just created.
	System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

	t.start();
	cdl1.await();

	System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

	cdl2.countDown();
	t.join();
	System.out.println(filterForThread(getThreadEventMessages(), thread_name).toString());

	System.out.println("Thread joined");

	enableThreadEvents(false);
	}

	private final static Comparator<Thread> THREAD_COMP = new Comparator<Thread>() {
	public int compare(Thread o1, Thread o2) {
	return o1.getName().compareTo(o2.getName());
	}
	};

	private final static Map<Integer, String> STATE_NAMES = new HashMap<Integer, String>();
	private final static List<Integer> STATE_KEYS = new ArrayList<Integer>();
	static {
	STATE_NAMES.put(0x1, "ALIVE");
	STATE_NAMES.put(0x2, "TERMINATED");
	STATE_NAMES.put(0x4, "RUNNABLE");
	STATE_NAMES.put(0x400, "BLOCKED_ON_MONITOR_ENTER");
	STATE_NAMES.put(0x80, "WAITING");
	STATE_NAMES.put(0x10, "WAITING_INDEFINITELY");
	STATE_NAMES.put(0x20, "WAITING_WITH_TIMEOUT");
	STATE_NAMES.put(0x40, "SLEEPING");
	STATE_NAMES.put(0x100, "IN_OBJECT_WAIT");
	STATE_NAMES.put(0x200, "PARKED");
	STATE_NAMES.put(0x100000, "SUSPENDED");
	STATE_NAMES.put(0x200000, "INTERRUPTED");
	STATE_NAMES.put(0x400000, "IN_NATIVE");
	STATE_KEYS.addAll(STATE_NAMES.keySet());
	Collections.sort(STATE_KEYS);
	}

	// Call getThreadState 'votes' times waiting 'wait' millis between calls and print the most common
	// result.
	private static void printMajorityThreadState(Thread t, int votes, int wait) throws Exception {
	Map<Integer, Integer> states = new HashMap<>();
	for (int i = 0; i < votes; i++) {
	int cur_state = getThreadState(t);
	states.put(cur_state, states.getOrDefault(cur_state, 0) + 1);
	Thread.sleep(wait); // Wait a little bit.
	}
	int best_state = -1;
	int highest_count = 0;
	for (Map.Entry<Integer, Integer> e : states.entrySet()) {
	if (e.getValue() > highest_count) {
	highest_count = e.getValue();
	best_state = e.getKey();
	}
	}
	printThreadState(best_state);
	}

	private static void printThreadState(Thread t) {
	printThreadState(getThreadState(t));
	}

	private static void printThreadState(int state) {
	StringBuilder sb = new StringBuilder();

	for (Integer i : STATE_KEYS) {
	if ((state & i) != 0) {
	if (sb.length()>0) {
	sb.append('\|');
	}
	sb.append(STATE_NAMES.get(i));
	}
	}

	if (sb.length() == 0) {
	sb.append("NEW");
	}

	System.out.println(Integer.toHexString(state) + " = " + sb.toString());
	}

	private static void printThreadInfo(Thread t) {
	Object[] threadInfo = getThreadInfo(t);
	if (threadInfo == null \|\| threadInfo.length != 5) {
	System.out.println(Arrays.toString(threadInfo));
	throw new RuntimeException("threadInfo length wrong");
	}

	System.out.println(threadInfo[0]); // Name
	System.out.println(threadInfo[1]); // Priority
	System.out.println(threadInfo[2]); // Daemon
	System.out.println(threadInfo[3]); // Threadgroup
	System.out.println(threadInfo[4] == null ? "null" : threadInfo[4].getClass()); // Context CL.
	}

	public static final class NativeWaiter {
	public long struct;
	public NativeWaiter() {
	struct = nativeWaiterStructAlloc();
	}
	public void waitForNative() {
	if (struct == 0l) {
	throw new Error("Already resumed from native!");
	}
	nativeWaiterStructWaitForNative(struct);
	}
	public void finish() {
	if (struct == 0l) {
	throw new Error("Already resumed from native!");
	}
	nativeWaiterStructFinish(struct);
	struct = 0;
	}
	}

	private static native long nativeWaiterStructAlloc();
	private static native void nativeWaiterStructWaitForNative(long struct);
	private static native void nativeWaiterStructFinish(long struct);
	private static native void nativeLoop(long w);

	private static native Thread getCurrentThread();
	private static native Object[] getThreadInfo(Thread t);
	private static native int getThreadState(Thread t);
	private static native Thread[] getAllThreads();
	private static native void setTLS(Thread t, long l);
	private static native long getTLS(Thread t);
	private static native void enableThreadEvents(boolean b);
	private static native String[] getThreadEventMessages();
	}