| AShuttleAnimator.java |
package lectures.animation.threads_commands;
import util.annotations.WebDocuments;
import util.annotations.Visible;
import lectures.animation.threads_commands.extra.ThreadSupport;
import lectures.composite.objects_shapes.PlottedShuttle;
import bus.uigen.OEFrame;
/**
* This is the class that does the actual animation and prints the Thread objects.
*
* Put a break point at the println() in animateFromOrigin that prints the
* Thread object. Then debug-run the main method in ConcurrentShuttleLaunchAnimation.
*
* After the breakpoint is hit, follow the instructions at the bottom of this class.
*
*
*/
@WebDocuments({"Lectures/AnimationThreadsCommands.pptx", "Lectures/AnimationThreadsCommands.pdf", "Videos/AnimationThreadsCommands.avi"})
public class AShuttleAnimator implements ShuttleAnimator {
@Visible(false)
public void animateFromOrigin(PlottedShuttle shuttle, int animationStep, int animationPauseTime) {
/*
* Put a break point below
*/
System.out.println (
Thread.currentThread()+
" entered animateFromOrigin in:" +
this);
int originalX = shuttle.getShuttleX();
int originalY = shuttle.getShuttleY();
System.out.println (Thread.currentThread() + " saved X = " + originalX + " Y = " + originalY);
int curX = 0;
int curY = 0;
shuttle.setShuttleX(curX);
shuttle.setShuttleY(curY);
animateYFromOrigin(shuttle, animationStep, animationPauseTime, curY, originalY);
animateXFromOrigin(shuttle, animationStep, animationPauseTime, curX, originalX);
}
protected void animateYFromOrigin(PlottedShuttle shuttle, int animationStep, int animationPauseTime, int startY, int endY) {
System.out.println (
Thread.currentThread()+
" started animating in Y Direction in:" +
this);
// make sure we don�t go past final Y position
while (startY < endY) {
ThreadSupport.sleep(animationPauseTime);
startY += animationStep;
shuttle.setShuttleY(startY);
}
// move to destination Y position
shuttle.setShuttleY(endY);
System.out.println (
Thread.currentThread()+
" finished animating in Y Direction in:" +
this);
}
protected void animateXFromOrigin(PlottedShuttle shuttle, int animationStep, int animationPauseTime, int startX, int endX) {
System.out.println (
Thread.currentThread()+
" started animating in X Direction in:" +
this);
while (startX < endX) {
ThreadSupport.sleep(animationPauseTime);
startX += animationStep;
shuttle.setShuttleX(startX);
}
shuttle.setShuttleX(endX);
System.out.println (
Thread.currentThread()+
" finished animating in X Direction in:" +
this);
}
@Override
public String toString() {
return getClass().getSimpleName() + "@" + hashCode();
}
/*
* When the breakpoint is hit, look carefully at the Debug window showing stack information.
* You will see that the window is partitioned by Threads in a tree window.
* That is, the debug window shows a tree of Thread objects, and some of these
* objects can be expanded or collapsed to show stacks.
*
* So far, we have assumed there is only one stack of method calls.
* In fact, there is a stack per thread.
*
*
* This means that each method call is associated with some thread. When a method is
* called, it can print out the associated thread by printing out Thread.currentThread(),
* as we see above.
*
* The main method is associated with a special thread, called the main thread.
*
* We can have other threads, which do not have the main method.
*
* These other threads are created by main. Once created they run independently
* of the main thread. That is, they make method calls independently,
* possibly at the same time (if we have multiple cores/CPUs).
*
* This is much like a parent creating children who can execute independently.
*
* The child threads can continue execution even after the main method has finished.
*
* A new Thread object must be created for each child thread.
*
* This means that the base call in a child thread is not main(). Instead it is the
* run method of the Thread object.
*
* In our example, it means that the method concurrentShuttleAnimation in the
* main class does not call the animating code in this class directly.
*
* Instead, the code creates and starts two new threads, which execute the
* two animations concurrently.
*
*
* Examine the debug window carefully.
*
* Not all stacks can be expanded. Only stacks with method calls that have stopped
* at a break point can be expanded.
*
* Look at the expandable stacks, both when serialShuttleAnimation executes
* and concurrentShuttleAnimation executes.
*
* Also look at the method call at the base (bottom) of each stack and trace
* the calls from this method to the call to the stopped method.
*
* Select the stopped method call in one of the stopped threads and resume and see
* the effect on the ObjectEditor window (make sure the debug window and
* object editor windows can be viewed at the same time).
*
* If the break point is hit again, go through this process again.
*
* The main method prints the message "Main terminates" just before it terminates.
*
* Search for this output in the console during the serial and concurrent executions.
*
*
* During serial animation, the number of stopped ("suspended") threads shown in the
* debug window is:
* 0
* 1
* 2
* 3
*
* (T/F) During serial animation, Thread[main] is one of the current threads.
*
* (T/F) During serial animation, Thread[main] is one of the stopped threads.
*
* (T/F) During serial animation, Thread[Shuttle Animation 1] is one of the current threads.
*
* (T/F) During serial animation, Thread[Shuttle Animation 2] is one of the current threads.
*
* (T/F) During serial animation, Thread[Shuttle Animation 1] is one of the stopped threads.
*
* (T/F) During serial animation, Thread[Shuttle Animation 2] is one of the stopped threads.
*
* (T/F) During serial animation, the base (bottom) of one of the stacks is
* the main() method.
*
* (T/F) During serial animation, the base (bottom) of one of the stacks is
* the Thread.run() method.
*
* (T/F) During serial animation, serialShuttleAnimation() is one of the called
* methods in a stack.
*
* (T/F) During serial animation, the stopped animateFromOrigin() method is called by
* AShuttleAnimationCommand.run().
*
* (T/F) During serial animation, AShuttleAnimationCommand.run() is called by
* Thread.run().
*
*
* (T/F) During serial animation, the message "Main terminates" is the last output
* in the console.
*
*
* During concurrent execution, the number of stopped ("suspended") threads shown in
* the debug window is:
* 0
* 1
* 2
* 3
*
* (T/F) During concurrent animation, Thread[main] is one of the current threads.
*
* (T/F) During concurrent animation, Thread[main] is one of the stopped threads.
*
* (T/F) During concurrent animation, Thread[Shuttle Animation 1] is one of the current threads.
*
* (T/F) During concurrent animation, Thread[Shuttle Animation 2] is one of the current threads.
*
* (T/F) During concurrent animation, Thread[Shuttle Animation 1] is one of the stopped threads.
*
* (T/F) During concurrent animation, Thread[Shuttle Animation 2] is one of the stopped threads.
*
* (T/F) During concurrent animation, the base (bottom) of one of the stacks is
* the main() method.
*
* (T/F) During concurrent animation, the base (bottom) of one of the stacks is
* the Thread.run() method.
*
* (T/F) During concurrent animation, serialShuttleAnimation() is one of the called
* methods in a stack.
*
* (T/F) During concurrent animation, concurrentShuttleAnimation() is one of the called
* methods in a stack.
*
* (T/F) During concurrent animation, the program has to be resumed twice to finish
* the animation.
*
* (T/F) During concurrent animation, the stopped animateFromOrigin method is called by
* AShuttleAnimationCommand.run().
*
* (T/F) During concurrent animation, AShuttleAnimationCommand.run() is called by
* Thread.run().
*
* (T/F) During concurrent animation, the message "main terminates" is the last output
* in the console.
*
* (T/F) Other threads in a program can continue to execute after the main method
* and thread of the program terminates.
*
* Study the code in this class and step over the println if necessary:
*
* (T/F) The class AShuttleAnimator implements separate methods to animate the shuttle
* in the X and Y directions.
*
*
* Go back to ConcurrentShuttleLaunchAnimation, to the COMMAND OBJECTS section.
*/
}