001: //
002: // Copyright (C) 2005 United States Government as represented by the
003: // Administrator of the National Aeronautics and Space Administration
004: // (NASA). All Rights Reserved.
005: //
006: // This software is distributed under the NASA Open Source Agreement
007: // (NOSA), version 1.3. The NOSA has been approved by the Open Source
008: // Initiative. See the file NOSA-1.3-JPF at the top of the distribution
009: // directory tree for the complete NOSA document.
010: //
011: // THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY
012: // KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT
013: // LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO
014: // SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
015: // A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT
016: // THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT
017: // DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE.
018: //
019: package java.lang;
020:
021: /**
022: * MJI model class for java.lang.Thread library abstraction
023: */
024: public class Thread implements Runnable {
025: public static final int MIN_PRIORITY = 1;
026: public static final int NORM_PRIORITY = 5;
027: public static final int MAX_PRIORITY = 10;
028: static int threadNum;
029: ThreadGroup group;
030: Runnable target;
031: String name;
032: int priority;
033: boolean isDaemon;
034:
035: // <2do> those two seem to be the only interfaces to the ThreadLocal
036: // implementation. Replace once we have our own
037: // ThreadLocal / InhertitableThreadLocal classes
038: ThreadLocal.ThreadLocalMap threadLocals;
039: ThreadLocal.ThreadLocalMap inheritableThreadLocals;
040:
041: public Thread() {
042: init(group, target, name, 0L);
043: }
044:
045: public Thread(Runnable target) {
046: init(group, target, name, 0L);
047: }
048:
049: public Thread(Runnable target, String name) {
050: init(group, target, name, 0L);
051: }
052:
053: public Thread(String name) {
054: init(group, target, name, 0L);
055: }
056:
057: public Thread(ThreadGroup group, Runnable target) {
058: init(group, target, name, 0L);
059: }
060:
061: public Thread(ThreadGroup group, Runnable target, String name) {
062: init(group, target, name, 0L);
063: }
064:
065: public Thread(ThreadGroup group, Runnable target, String name,
066: long stackSize) {
067: init(group, target, name, 0L);
068: }
069:
070: public Thread(ThreadGroup group, String name) {
071: init(group, target, name, 0L);
072: }
073:
074: public static int activeCount() {
075: return 0;
076: }
077:
078: public void setContextClassLoader(ClassLoader cl) {
079: }
080:
081: public ClassLoader getContextClassLoader() {
082: // <NSY>
083: return null;
084: }
085:
086: public synchronized void setDaemon(boolean isDaemon) {
087: this .isDaemon = isDaemon;
088: setDaemon0(isDaemon);
089: }
090:
091: public boolean isDaemon() {
092: return isDaemon;
093: }
094:
095: public synchronized void setName(String name) {
096: if (name == null) {
097: throw new IllegalArgumentException(
098: "thread name can't be null");
099: }
100:
101: this .name = name;
102: setName0(name);
103: }
104:
105: public String getName() {
106: return name;
107: }
108:
109: public void setPriority(int priority) {
110: if ((priority < MIN_PRIORITY) || (priority > MAX_PRIORITY)) {
111: throw new IllegalArgumentException(
112: "thread priority out of range");
113: }
114:
115: this .priority = priority;
116: setPriority0(priority);
117: }
118:
119: public int getPriority() {
120: return priority;
121: }
122:
123: public ThreadGroup getThreadGroup() {
124: return group;
125: }
126:
127: public void checkAccess() {
128: // <NSY>
129: }
130:
131: public native int countStackFrames();
132:
133: public static native Thread currentThread();
134:
135: public void destroy() {
136: }
137:
138: public static void dumpStack() {
139: }
140:
141: public static int enumerate(Thread[] tarray) {
142: Thread cur = currentThread();
143:
144: return cur.group.enumerate(tarray);
145: }
146:
147: public static native boolean holdsLock(Object obj);
148:
149: public native void interrupt();
150:
151: public static boolean interrupted() {
152: return currentThread().isInterrupted();
153: }
154:
155: public native boolean isAlive();
156:
157: public native boolean isInterrupted();
158:
159: public synchronized void join() throws InterruptedException {
160: while (isAlive()) {
161: wait();
162: }
163: }
164:
165: //public native synchronized void join () throws InterruptedException;
166:
167: public void join(long millis) throws InterruptedException {
168: join(); // no timeout supported yet
169: }
170:
171: public void join(long millis, int nanos)
172: throws InterruptedException {
173: join(); // no timeout supported yet
174: }
175:
176: public void run() {
177: }
178:
179: public static native void sleep(long millis)
180: throws InterruptedException;
181:
182: public static native void sleep(long millis, int nanos)
183: throws InterruptedException;
184:
185: public native void start();
186:
187: public void stop() {
188: // deprecated, <NSY>
189: }
190:
191: public void suspend() {
192: // deprecated <NSY>
193: }
194:
195: public String toString() {
196: return ("Thread[" + name + ',' + priority + ','
197: + group.getName() + ']');
198: }
199:
200: public static native void yield();
201:
202: native void setDaemon0(boolean on);
203:
204: native void setName0(String name);
205:
206: native void setPriority0(int priority);
207:
208: void init(ThreadGroup group, Runnable target, String name,
209: long stackSize) {
210: Thread cur = currentThread();
211:
212: if (group == null) {
213: this .group = cur.getThreadGroup();
214: } else {
215: this .group = group;
216: }
217:
218: this .group.add(this );
219:
220: if (name == null) {
221: this .name = "Thread-" + threadNum++;
222: } else {
223: this .name = name;
224: }
225:
226: // those are always inherited from the current thread
227: this .priority = cur.getPriority();
228: this .isDaemon = cur.isDaemon();
229:
230: this .target = target;
231:
232: // do our associated native init
233: init0(this .group, target, this .name, stackSize);
234: }
235:
236: native void init0(ThreadGroup group, Runnable target, String name,
237: long stackSize);
238: }
|