| /libcore/luni/src/main/java/java/lang/ |
| Thread.java | 43 * A {@code Thread} is a concurrent unit of execution. It has its own call stack
45 * has at least one thread running when it is started, the main thread, in the main
46 * {@link ThreadGroup}. The runtime keeps its own threads in the system thread
49 * <p>There are two ways to execute code in a new thread.
50 * You can either subclass {@code Thread} and overriding its {@link #run()} method,
51 * or construct a new {@code Thread} and pass a {@link Runnable} to the constructor.
53 * the new {@code Thread}.
55 * <p>Each {@code Thread} has an integer priority that affect how the thread i
503 Thread thread = Thread.currentThread(); local
595 VMThread thread = vmThread; local
[all...] |
| ThreadGroup.java | 28 * This class is obsolete. See <i>Effective Java</i> Item 73, "Avoid thread groups" for details.
29 * @see Thread
31 public class ThreadGroup implements Thread.UncaughtExceptionHandler {
38 private int maxPriority = Thread.MAX_PRIORITY;
48 private final List<WeakReference<Thread>> threadRefs = new ArrayList<WeakReference<Thread>>(5);
54 private final Iterable<Thread> threads = CollectionUtils.dereferenceIterable(threadRefs, true);
57 * Thread groups. Access is guarded by synchronizing on this field.
73 * will be child of the {@code ThreadGroup} to which the calling thread belongs.
76 * @see Thread#currentThrea
342 Thread thread = threadRefs.get(i).get(); local
[all...] |
| /dalvik/tests/033-class-init-deadlock/src/ |
| Main.java | 13 Thread thread1, thread2;
16 thread1 = new Thread() { public void run() { new A(); } };
17 thread2 = new Thread() { public void run() { new B(); } };
20 try { Thread.sleep(1000); } catch (InterruptedException ie) { }
23 try { Thread.sleep(6000); } catch (InterruptedException ie) { }
28 System.out.println("Deadlock test main thread bailing.");
38 try { Thread.sleep(3000); } catch (InterruptedException ie) { }
48 try { Thread.sleep(3000); } catch (InterruptedException ie) { }
|
| /dalvik/tests/084-class-init/ |
| expected.txt | 8 Fields (child thread): 111222333444
9 Fields (main thread): 111222333444
|
| /dalvik/vm/mterp/mips/ |
| OP_THROW.S | 4 * Throw an exception object in the current thread.
13 STORE_offThread_exception(a1, rSELF) # thread->exception <- obj
|
| /dalvik/vm/mterp/x86/ |
| OP_THROW.S | 4 * Throw an exception object in the current thread.
12 movl %eax,offThread_exception(%ecx) # thread->exception<- obj
|
| /external/chromium/base/threading/ |
| thread.cc | 5 #include "base/threading/thread.h"
16 // We use this thread-local variable to record whether or not a thread exited
19 // Thread to setup and run a MessageLoop.
30 Thread::SetThreadWasQuitProperly(true);
36 struct Thread::StartupData {
38 const Thread::Options& options;
40 // Used to synchronize thread startup.
48 Thread::Thread(const char* name
[all...] |
| /external/llvm/test/CodeGen/ARM/ |
| thread_pointer.ll | 6 %tmp1 = call i8* @llvm.arm.thread.pointer( ) ; <i8*> [#uses=0]
10 declare i8* @llvm.arm.thread.pointer()
|
| /external/valgrind/main/exp-bbv/tests/amd64-linux/ |
| clone_test.stderr.exp | 0 # Thread 1
7 # Thread 2
|
| /external/valgrind/main/exp-bbv/tests/x86-linux/ |
| clone_test.stderr.exp | 0 # Thread 1
7 # Thread 2
|
| /external/valgrind/main/gdbserver_tests/ |
| mcinfcallWSRU.stdinB.gdb | 20 thread 1
21 print whoami("thread 1 inferior call pushed from gdb in mcinfcallWSRU.stdinB.gdb")
22 thread 2
23 print whoami("thread 2 inferior call pushed from gdb in mcinfcallWSRU.stdinB.gdb")
24 thread 3
25 print whoami("thread 3 inferior call pushed from gdb in mcinfcallWSRU.stdinB.gdb")
26 thread 4
27 print whoami("thread 4 inferior call pushed from gdb in mcinfcallWSRU.stdinB.gdb")
|
| /external/valgrind/main/memcheck/tests/ |
| err_disable4.vgtest | 4 ## This is so as to get rid of the "Thread #" lines, which
6 ## thread scheduling between runs.
|
| err_disable4.stderr.exp | 4 WARNING: exiting thread has error reporting disabled.
7 WARNING: exiting thread has error reporting disabled.
10 WARNING: exiting thread has error reporting disabled.
13 WARNING: exiting thread has error reporting disabled.
16 WARNING: exiting thread has error reporting disabled.
19 WARNING: exiting thread has error reporting disabled.
22 WARNING: exiting thread has error reporting disabled.
25 WARNING: exiting thread has error reporting disabled.
28 WARNING: exiting thread has error reporting disabled.
31 WARNING: exiting thread has error reporting disabled
[all...] |
| /libcore/luni/src/main/java/java/util/concurrent/locks/ |
| AbstractOwnableSynchronizer.java | 10 * A synchronizer that may be exclusively owned by a thread. This
35 private transient Thread exclusiveOwnerThread;
38 * Sets the thread that currently owns exclusive access. A
39 * <tt>null</tt> argument indicates that no thread owns access.
43 protected final void setExclusiveOwnerThread(Thread t) {
48 * Returns the thread last set by
52 * @return the owner thread
54 protected final Thread getExclusiveOwnerThread() {
|
| /libcore/dalvik/src/main/java/dalvik/system/profiler/ |
| SamplingProfiler.java | 30 * Thread.getStackTrace} to collect samples. As such, the overhead is
38 * SamplingProfiler}. It samples the current thread's stack to a depth
44 * ThreadSet threadSet = SamplingProfiler.newArrayThreadSet(Thread.currentThread());
94 * Real hprof output examples don't start the thread and trace
105 * thread start and end events.
107 private Thread[] currentThreads = new Thread[0];
114 private final Map<Thread, Integer> threadIds = new HashMap<Thread, Integer>();
120 * be thread safe, have a single mutable instance would need to b
[all...] |
| /bionic/libc/bionic/ |
| pthread_join.cpp | 38 pthread_accessor thread(t);
39 if (thread.get() == NULL) {
43 if (thread->attr.flags & PTHREAD_ATTR_FLAG_DETACHED) {
47 // Wait for thread death when needed.
49 // If the 'join_count' is negative, this is a 'zombie' thread that
52 int count = thread->join_count;
54 thread->join_count += 1;
55 pthread_cond_wait(&thread->join_cond, &gThreadListLock);
56 count = --thread->join_count;
59 *ret_val = thread->return_value
[all...] |
| /external/qemu/distrib/sdl-1.2.15/src/thread/os2/ |
| SDL_systhread.c | 24 /* OS/2 thread management routines for SDL */
46 // Call the thread function!
60 int SDL_SYS_CreateThread(SDL_Thread *thread, void *args, pfnSDL_CurrentBeginThread pfnBeginThread, pfnSDL_CurrentEndThread pfnEndThread)
65 SDL_SetError("Not enough memory to create thread");
71 // Also save the real parameters we have to pass to thread function
73 // Start the thread using the runtime library of calling app!
74 thread->threadid = thread->handle = (*pfnBeginThread)(threadfunc, NULL, 512*1024, pThreadParms);
75 if ((int)thread->threadid <= 0)
77 SDL_SetError("Not enough resources to create thread");
[all...] |
| /external/qemu/distrib/sdl-1.2.15/src/thread/pthread/ |
| SDL_systhread.c | 38 /* RISC OS needs to know the main thread for
41 Uint32 riscos_main_thread = 0; /* Thread running events */
52 int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
56 /* Set the thread attributes */
63 /* Create the thread and go! */
64 if ( pthread_create(&thread->handle, &type, RunThread, args) != 0 ) {
65 SDL_SetError("Not enough resources to create thread");
84 /* Mask asynchronous signals for this thread */
105 void SDL_SYS_WaitThread(SDL_Thread *thread)
107 pthread_join(thread->handle, 0)
[all...] |
| /dalvik/vm/mterp/common/ |
| asm-constants.h | 148 /* Thread fields */
149 MTERP_OFFSET(offThread_pc, Thread, interpSave.pc, 0)
150 MTERP_OFFSET(offThread_curFrame, Thread, interpSave.curFrame, 4)
151 MTERP_OFFSET(offThread_method, Thread, interpSave.method, 8)
152 MTERP_OFFSET(offThread_methodClassDex, Thread, interpSave.methodClassDex, 12)
154 MTERP_OFFSET(offThread_retval, Thread, interpSave.retval, 16)
156 MTERP_OFFSET(offThread_retval_z, Thread, interpSave.retval.z, 19)
158 MTERP_OFFSET(offThread_retval_z, Thread, interpSave.retval.z, 16)
160 MTERP_OFFSET(offThread_retval_i, Thread, interpSave.retval.i, 16)
161 MTERP_OFFSET(offThread_retval_j, Thread, interpSave.retval.j, 16
[all...] |
| /dalvik/vm/ |
| Sync.h | 51 * Lock owner field. Contains the thread id of the thread currently
68 struct Thread;
78 extern "C" void dvmLockObject(Thread* self, Object* obj);
83 extern "C" bool dvmUnlockObject(Thread* self, Object* obj);
88 void dvmObjectWait(Thread* self, Object* obj,
90 void dvmObjectNotify(Thread* self, Object* obj);
91 void dvmObjectNotifyAll(Thread* self, Object* obj);
99 * Implementation of Thread.sleep().
104 * Implementation of Thread.interrupt()
[all...] |
| /external/valgrind/main/helgrind/tests/ |
| tc04_free_lock.stderr.exp | 2 ---Thread-Announcement------------------------------------------
4 Thread #x is the program's root thread
8 Thread #x: Exiting thread still holds 2 locks
|
| /external/qemu/distrib/sdl-1.2.15/src/thread/ |
| SDL_systhread.h | 31 /* This function creates a thread, passing args to SDL_RunThread(),
32 saves a system-dependent thread id in thread->id, and returns 0
36 extern int SDL_SYS_CreateThread(SDL_Thread *thread, void *args, pfnSDL_CurrentBeginThread pfnBeginThread, pfnSDL_CurrentEndThread pfnEndThread);
38 extern int SDL_SYS_CreateThread(SDL_Thread *thread, void *args);
41 /* This function does any necessary setup in the child thread */
44 /* This function waits for the thread to finish and frees any data
47 extern void SDL_SYS_WaitThread(SDL_Thread *thread);
49 /* This function kills the thread and returns */
50 extern void SDL_SYS_KillThread(SDL_Thread *thread);
[all...] |
| /libcore/luni/src/test/java/libcore/java/lang/ |
| OldThreadGroupTest.java | 27 public class OldThreadGroupTest extends TestCase implements Thread.UncaughtExceptionHandler {
29 class MyThread extends Thread {
42 Thread.sleep(50);
58 Thread.yield();
75 Thread t1 = new Thread(tg, new Runnable() {
95 ThreadGroup tg = new ThreadGroup("thread suspension");
96 assertTrue("Thread suspention can not be changed",
98 assertTrue("Thread suspention can not be changed",
103 * Checks whether the current Thread is in the given list
286 Thread thread = launchFiveSecondDummyThread(group); local
302 Thread thread = new Thread(group, "Bar") { local
[all...] |
| /external/apache-xml/src/main/java/org/apache/xml/utils/ |
| ThreadControllerWrapper.java | 33 public static Thread runThread(Runnable runnable, int priority)
38 public static void waitThread(Thread worker, Runnable task)
45 * Thread controller utility class for incremental SAX source. Must
46 * be overriden with a derived class to support thread pooling.
48 * All thread-related stuff is in this class.
54 * Will get a thread from the pool, execute the task
55 * and return the thread to the pool.
63 * @return The thread that is running the task, can be used
66 public Thread run(Runnable task, int priority)
69 Thread t = new Thread(task)
[all...] |
| /external/chromium/third_party/libjingle/source/talk/base/ |
| signalthread.h | 33 #include "talk/base/thread.h"
39 // SignalThread - Base class for worker threads. The main thread should call
42 // Cancellation: Call Release(true), to abort the worker thread.
43 // Fire-and-forget: Call Release(false), which allows the thread to run to
48 // on a new thread.
52 // tasks in the context of the main thread.
59 // Context: Main Thread. Call before Start to change the worker's name.
62 // Context: Main Thread. Call before Start to change the worker's priority.
65 // Context: Main Thread. Call to begin the worker thread
[all...] |
