001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: *
015: * See the License for the specific language governing permissions and
016: * limitations under the License.
017: */
018:
019: /**
020: * @author Anatoly F. Bondarenko
021: * @version $Revision: 1.3 $
022: */
023:
024: /**
025: * Created on 08.06.2006
026: */package org.apache.harmony.jpda.tests.jdwp.ThreadReference;
027:
028: import org.apache.harmony.jpda.tests.share.SyncDebuggee;
029:
030: public class ResumeDebuggee extends SyncDebuggee {
031: public static final int THREAD_NUMBER_LIMIT = 6;
032: public static final String THREAD_NAME_PATTERN = "ResumeDebuggee_Thread_";
033: public static final String TO_FINISH_DEBUGGEE_FIELD_NAME = "debuggeToFinish";
034:
035: static ResumeDebuggee resumeDebuggeeThis;
036:
037: static volatile boolean allThreadsToFinish = false;
038: static int debuggeToFinish = 0;
039: static int createdThreadsNumber = 0;
040: static volatile int startedThreadsNumber = 0;
041:
042: static ResumeDebuggee_Thread[] resumeDebuggeeThreads = null;
043:
044: static Object waitTimeObject = new Object();
045:
046: static void waitMlsecsTime(long mlsecsTime) {
047: synchronized (waitTimeObject) {
048: try {
049: waitTimeObject.wait(mlsecsTime);
050: } catch (Throwable throwable) {
051: // ignore
052: }
053: }
054: }
055:
056: static void sleepMlsecsTime(long mlsecsTime) {
057: try {
058: Thread.sleep(mlsecsTime);
059: } catch (Throwable throwable) {
060: // ignore
061: }
062: }
063:
064: public void run() {
065:
066: logWriter.println("--> ResumeDebuggee: START...");
067: resumeDebuggeeThis = this ;
068:
069: logWriter
070: .println("--> ResumeDebuggee: Create and start tested threads...");
071: try {
072: resumeDebuggeeThreads = new ResumeDebuggee_Thread[THREAD_NUMBER_LIMIT];
073: for (int i = 0; i < THREAD_NUMBER_LIMIT; i++) {
074: resumeDebuggeeThreads[i] = new ResumeDebuggee_Thread(i);
075: resumeDebuggeeThreads[i].start();
076: createdThreadsNumber++;
077: }
078: } catch (Throwable thrown) {
079: logWriter
080: .println("--> ResumeDebuggee: Exception while creating threads: "
081: + thrown);
082: }
083: logWriter
084: .println("--> ResumeDebuggee: Created threads number = "
085: + createdThreadsNumber);
086:
087: while (startedThreadsNumber != createdThreadsNumber) {
088: waitMlsecsTime(100);
089: }
090: if (createdThreadsNumber != 0) {
091: logWriter
092: .println("--> ResumeDebuggee: All created threads are started!");
093: }
094:
095: synchronizer
096: .sendMessage(Integer.toString(createdThreadsNumber));
097:
098: String mainThreadName = Thread.currentThread().getName();
099: synchronizer.sendMessage(mainThreadName);
100:
101: logWriter
102: .println("--> ResumeDebuggee: Wait for signal from test to finish...");
103: while (debuggeToFinish != 99) { // is set up by debugger - ResumeTest
104: waitMlsecsTime(100);
105: }
106:
107: logWriter
108: .println("--> ResumeDebuggee: Send signal to all threads to finish and wait...");
109: allThreadsToFinish = true;
110:
111: for (int i = 0; i < createdThreadsNumber; i++) {
112: while (resumeDebuggeeThreads[i].isAlive()) {
113: waitMlsecsTime(10);
114: }
115: }
116: logWriter.println("--> ResumeDebuggee: All threads finished!");
117:
118: logWriter.println("--> ResumeDebuggee: FINISH...");
119:
120: }
121:
122: public static void main(String[] args) {
123: runDebuggee(ResumeDebuggee.class);
124: }
125:
126: }
127:
128: class ResumeDebuggee_Thread extends Thread {
129:
130: int threadKind;
131:
132: public ResumeDebuggee_Thread(int threadNumber) {
133: super (ResumeDebuggee.THREAD_NAME_PATTERN + threadNumber);
134: threadKind = threadNumber % 3;
135: }
136:
137: public void run() {
138: ResumeDebuggee parent = ResumeDebuggee.resumeDebuggeeThis;
139: synchronized (parent) {
140: ResumeDebuggee.startedThreadsNumber++;
141: }
142: while (!ResumeDebuggee.allThreadsToFinish) {
143: switch (threadKind) {
144: case 0:
145: ResumeDebuggee.waitMlsecsTime(100);
146: break;
147: case 1:
148: ResumeDebuggee.sleepMlsecsTime(100);
149: }
150: }
151: }
152: }
|