代做CS5002 Advanced Programming Assessed Exercise II 2025代做Java编程
- 首页 >> Database作业Assessed Exercise II
CS5002 Advanced Programming
February 2025
• Deadline: 16:30 on 17th March 2025
• Contribution to final course mark: 25%
• Solo or Group: Solo work
• Anticipated duration: 4 hours
Introduction
From the course Moodle page, download the files CommandRunner.java and SlowCalculator.java. The latter contains a class SlowCalculator implement- ing Runnable. Its constructor takes a number N as input and stores it. Method run performs a long, slow calculation on this number, then prints the result. You do not need to consider (or even understand) the mathematical details of what is being calculated!
In this exercise, you will write a class implementing the interface CommandRunner, that runs certain commands passed as strings. These are inputs from a user, requesting the calculation be performed for particular numbers. The inputs and outputs are read/written by a separate part of the program – you just have to use the passed string, and return a string.
As the calculation is slow, you will run it on background threads, so the user can continue to interact with the system while tasks are running. To take advantage of modern multi-core CPUs, the user may request several calculations be run in parallel. Each calculation will still run on one single thread – your goal is to let the user run multiple calculations in parallel, not to make the individual calculations faster.
Task
You will write a class called Solution that implements the CommandRunner interface. The runCommand method of this class will be passed a string, cor- responding to a command the user entered. It should perform the relevant command (see below), and return the specified output string. You should not modify the interface CommandRunner in any way. Your Solution class should have a public constructor taking no parameters.
The following table lists the commands the user may enter (i.e. that may be passed as the command argument to your Solution.runCommand method), and the required behaviour of your runCommand method (note N and M are long integers chosen by the user):
start N start calculating with input N, by calling
SlowCalculator .run on a new thread; imme- diately return the message “started N”
cancel N immediately cancel the calculation with input N
that is currently running or pending with after (do nothing if it already completed or if it was never requested); when it has stopped (which should be within 0.1s) return message “cancelled N”
running return a message indicating the total number
of calculations currently running (i.e. exclud- ing those already completed/cancelled), and their inputs N (in any order), in the form “3 calculations running: 83476 1000 176544” . If no calculations are running, return the string “no calculations running” .
get N if the calculation for N is finished, return message
“result is M ” where M is the integer result; if the calculation is not yet finished, return message “calculating” . If the calculation was started but already cancelled, return message “cancelled” . If the calculation is scheduled with after but not yet started, return message “waiting” .
after N M schedule the calculation for M to start when that for
N finishes (or is cancelled). Return the message “M will start after N ” immediately (without wait- ing for either calculation). The calculation for M should not appear in running until it is actually running (i.e. N has completed). If N has already finished, M should start immediately. If a circular dependency would arise (i.e. two calculations wait- ing for each other, hence neither would start), then after should not schedule M , but instead return the message “circular dependency N ... M ” where ... is replaced by the numbers of all calculations scheduled after N (or after another that is itself af- ter N, recursively), and which M is itself scheduled after (these can be listed in any order)
finish wait for all calculations previously requested by the
user (including those scheduled with after) to fin- ish, and then after they are all completed, return message “finished”
abort immediately stop all running calculations (and dis-
card any scheduled using after), and then when they are stopped (which should be within 0.1s) re- turn message “aborted”
For any command not given above (including malformed commands, e.g. N is not an integer), the method should return message “Invalid command”
Note that the provided code for SlowCalculator prints the answer at the end of run(). You must remove this print statement, and replace it with a suitable mechanism to return the result so your Solution class can retrieve it. You should not modify the mathematical calculations performed by either SlowCalculator.calculateNumFactors or SlowCalculator.isPrime, but you will need to add support for interruption. You may change other parts of this class if you want (e.g. adding new fields or constructor parameters). You must not change the names of the existing methods.
Here is an example of what should happen when your program runs; the highlighted lines are commands passed to runCommand, and the remaining lines are the messages it returns:
Notes
• We will not test on pathological inputs for which the behaviour is not defined, i.e. not specified above. Please do not ask questions about any special cases you may think of (e.g. starting a calculation that is already running). It does not matter what your program does in such cases
• Do ensure you return “Invalid command” (as mentioned above) if you receive a command that is not of the required form (e.g. N is missing or not an integer, or a command is misspelt)
• Your program should not limit the number of calculations/threads that can be run in parallel
• Your program should not print any output directly, nor read from the console
• Do not use any deprecated methods, such as Thread.stop() (such meth- ods are typically deprecated because they are dangerous, and so it is bad practice to use them)
• Remember the goal of this exercise is not to make each individual calcu- lation parallel, but to run several independent calculations for different N in parallel!
Submission
• You must implement a class Solution in file Solution.java, inheriting from CommandRunner. Do not put your code in a Java package (i.e. do not use the package keyword in any files).
• You will submit a single .zip file (not a tar, or a rar, or anything else), named 1234567.zip where 1234567 is replaced by your 7-digit numeric student ID
• This .zip fileshall contain no folders, (e.g. src/), but only the .java files containing your code, including SlowCalculator.java and Solution.java, and maybe others if you wish
• Do not include CommandRunner.java in your submission
• Do not include a main method anywhere
• Upload your .zip file to Moodle before the deadline!
Mark Scheme
Your submission will be marked out of 65 points, broken down as follows:
• Code is provided in the correct form and compiles successfully [5]
• start, running, get and cancel commands work as expected [20]
• finish and abort commands work as expected [15]
• after command works as expected [25]
If you do not follow the exercise specification precisely, you will lose marks (your submission will be processed by a computer program; it will assume you’ve followed the instructions).