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 20.06.2006
026: */package org.apache.harmony.jpda.tests.jdwp.VirtualMachine;
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 = 10;
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: logWriter
069: .println("--> ResumeDebuggee: Create thread groups...");
070:
071: logWriter
072: .println("--> ResumeDebuggee: Create and start tested threads...");
073: try {
074: ResumeDebuggeeThreads = new ResumeDebuggee_Thread[THREAD_NUMBER_LIMIT];
075: for (int i = 0; i < THREAD_NUMBER_LIMIT; i++) {
076: ResumeDebuggeeThreads[i] = new ResumeDebuggee_Thread(i);
077: ResumeDebuggeeThreads[i].start();
078: createdThreadsNumber++;
079: }
080: } catch (Throwable thrown) {
081: logWriter
082: .println("--> ResumeDebuggee: Exception while creating threads: "
083: + thrown);
084: }
085: logWriter
086: .println("--> ResumeDebuggee: Created threads number = "
087: + createdThreadsNumber);
088:
089: while (startedThreadsNumber != createdThreadsNumber) {
090: waitMlsecsTime(100);
091: }
092: if (createdThreadsNumber != 0) {
093: logWriter
094: .println("--> ResumeDebuggee: All created threads are started!");
095: }
096:
097: synchronizer
098: .sendMessage(Integer.toString(createdThreadsNumber));
099:
100: String mainThreadName = Thread.currentThread().getName();
101: synchronizer.sendMessage(mainThreadName);
102:
103: logWriter
104: .println("--> ResumeDebuggee: Wait for signal from test to finish...");
105: while (debuggeToFinish != 99) { // is set up by debugger - ResumeTest
106: waitMlsecsTime(100);
107: }
108:
109: logWriter
110: .println("--> ResumeDebuggee: Send signal to all threads to finish and wait...");
111: allThreadsToFinish = true;
112:
113: for (int i = 0; i < createdThreadsNumber; i++) {
114: while (ResumeDebuggeeThreads[i].isAlive()) {
115: waitMlsecsTime(10);
116: }
117: }
118: logWriter.println("--> ResumeDebuggee: All threads finished!");
119:
120: logWriter.println("--> ResumeDebuggee: FINISH...");
121:
122: }
123:
124: public static void main(String[] args) {
125: runDebuggee(ResumeDebuggee.class);
126: }
127:
128: }
129:
130: class ResumeDebuggee_Thread extends Thread {
131:
132: int threadKind;
133:
134: public ResumeDebuggee_Thread(int threadNumber) {
135: super (ResumeDebuggee.THREAD_NAME_PATTERN + threadNumber);
136: threadKind = threadNumber % 3;
137: }
138:
139: public void run() {
140: ResumeDebuggee parent = ResumeDebuggee.ResumeDebuggeeThis;
141: synchronized (parent) {
142: ResumeDebuggee.startedThreadsNumber++;
143: }
144: while (!ResumeDebuggee.allThreadsToFinish) {
145: switch (threadKind) {
146: case 0:
147: ResumeDebuggee.waitMlsecsTime(100);
148: break;
149: case 1:
150: ResumeDebuggee.sleepMlsecsTime(100);
151: }
152: }
153: }
154: }
|