代做data编程、代写java程序设计、Java编程调试

日期：2020-11-20 10:58

Project 1

Due Date: Tuesday, November 17

THE KING IS DEAD, LONG LIVE THE KING!!!!

A castle starts with a certain number of defense points (number of defense points is

explained later in the ELSE IF section). If the castle defense value ever goes to <= 0, the

castle falls. There are G gates to a castle. For each entrance there are S free spaces.

The number of spaces is equal to the number of people that can hold the gate closed on

one side and equal to the number of people trying to break through the gate on the other

side.

Villagers have gotten angry at the sudden increase in taxes the King has set. They have

breached the outer castle walls and have taken over the armory. The attackers will, in

FCFS (first come first served) order, take a weapon from the armory and be assigned an

attack random integer value between 1 and 10 at the time the weapon is obtained.

(Note: Have the attackers block on the same object – armory). The defenders of the

castle can be assigned this value at runtime because they are already armed.

Upon receiving a weapon an attacker will head towards a gate and prepare to attack

(Note: In the beginning every attacker/defender searches for the least attacked/defended

gate to help out his friends. That is, an attacker compares every gates’ attackers and

picks the gate with the least attackers). No thread should be allowed to get to any of the

gates that are fully occupied. If no space to defend/attack is available at any gate, then

defenders/attackers just wait for free space. (Note: attackers/defenders wait in the order

of their arrival (FCFS). Use similar code to rwcv.java. Each attacker/defender gets an

object to wait on in that data structure - vectors). Upon arrival at the gate, the attacker

will wait for all of the defenders to arrive at the appropriate gate.

Likewise, the defenders will each choose a gate and wait for all of the attackers to arrive

at their gate.

Note: use the Gate as an object that both defenders and attackers will wait on. For each

gate there is an object named “Gate”.

Once all of the defenders and attackers are at the appropriate gate the battle can began.

The combined attack/defend values will be compared with the following conditions

below. The last thread to arrive at a gate notifies all waiting threads on the gate. While

the last thread will also execute sumUpAtackersDefendersValues() and do the

comparisons, the other threads will wait for the result on one object.

We will name a group of attackers/defenders gathered on a gate – company.

There may be other companies of threads that just finished attacking/defending and

want to do the comparison too. Make sure that multiple companies can do comparison

concurrently at company level but comparison is still synchronized within the same

company. You should use some identification for the same company (for example,

timestamp all company threads and assign company gate number, timestamp+gate#

would serve as unique id for company; each thread would carry that id within itself).

When a company is done with the comparison their gate status is either breached or

open for the king to try to escape (if attack/defend values matched, gate is as it was

before the siege began). Once the comparison is done and the threads start notifying

their respective reserve threads(first on line) and then rest. After rest they join the

reserves themselves.

IF:

Total defend value > total attack value: attackers are overwhelmed by defenders and

the gate is considered clear of attackers.

The King is a very sneaky person, when a gate is cleared of attackers, he will try to

escape. First he will need to gather his precious belongings and get ready. The King will

use the wait(long) method instead of the sleep method to simulate the packing time. If an

attacker arrives during this time, then the King will be signaled on the monitor wait(long)

and will retreat back into the castle.

If the gate at which the King is escaping through doesn’t have a new attacker when the

escape time elapses, then the King has succeeded in escaping and the attackers lose.

The time the king takes to get ready should be some factor less than the time an

attacker takes to rest.

Whenever an attacker that is coming to the siege sees a gate that was cleared of his

fellow attackers, he will try to attack that gate first. As soon as that attacker gets to that

gate, the defenders barricade it once more and the king has to wait for another

opportunity.

ELSE IF:

Total attack value > total defend value: attackers overwhelm defenders.

There's a number which represents the total castle defense. It is equal to the sum of

every single defender’s defense value. When attackers breach a gate, the sum of their

attack value is subtracted from the total castle defense (For example, if we have 100

defenders, their defense variable’s sum may equal 500, which means the castle’s

defense is also 500. If several attackers (with a total attack value of 50) breach one of

the gates, then the castle defense value is down to 450.)

Those attackers that were able to breach the gate and the defenders that failed to

protect the gate start attacking/defending again from the beginning. (Essentially, their

threads run in an infinite while (true) loop).

ELSE:

the battle is postponed.

If the castle’s defense value is at or below 0, the defenders lose.

---------------------------------------------------------------------------------------------------------------------

Develop a monitor(s) that will synchronize the threads (defenders, attackers, king) in the

context of the story described below. Closely follow the details of the story and the

synchronization requirements.

You can create any other methods/objects you may need. Make sure that any shared

variable/structure is accessed in a mutual exclusion fashion.

The number of attackers, defenders, gates to the castle, and free spaces for each

entrance can be read as command line arguments using the following format where a =

attackers, d = defenders, G = castle gates and S = free spaces:

Note that all command line arguments are optional. If they are not provided at run time,

your program should default to:

G*S+4 attackers, G*S+4 defenders; where G=3, and S=2.

Do NOT use busy waiting. If a thread needs to wait, it must wait on an object (class

object or notification object).

Use only basic monitors as the ones discussed in class (synchronized methods,

synchronized blocks, wait(), notify and notifyAll). Wait(long timeout) should be use once

only. NO other synchronization tools like locks, concurrent collections…..or even volatile

variables.

Use the age( ) method and appropriate println statements to show how synchronization

works. It is important to have print statements before, inside, and after critical events.

State clearly what the current thread executing the print statement is doing. Also, be

sure to include the name of the thread and a timestamp relative to the start time of the

program.

Suggestions:

The King’s thread should call

Method by which he’s waiting for the opportunity of escaping

Method by which he’s packing belongings.

Method by which he checks for a safe escape (if an attacker arrives during

that time the king should retreat back into the castle).

Attackers/Defenders call Castle’s methods:

Method(s) to find a defending/attacking position

or wait until all spaces are filled with attackers/defenders on both sides of the

gate

attack()/defend() should be simulated by sleep. Make sure that you give info

about the name of the thread and gate.

A method that will compute the attackers or defenders value

Between major events make sure you insert a sleep of random time. Also make sure

you give the information necessary to understand what that event is.

Choose the appropriate amount of time(s) that will agree with the content of the story. I

haven’t written the code for this project yet, but from the experience of grading previous

semesters’ projects, a project should take somewhere between 50 seconds and at most

2 minutes to run and complete. Set the time in such way that you don’t create only

exceptional situations.

Do not submit any code that does not compile and run. If there are parts of the code that

contain bugs, comment it out and leave the code in. A program that does not compile

nor run will not be graded.

Follow the story closely and cover the requirements of the project’s description. Besides

the synchronization details provided there are other synchronization aspects that need to

be covered. You can use synchronized methods or additional synchronized blocks to

make sure that mutual exclusion over shared variables is satisfied.

The Main class is run by the main thread. The other threads must be specified by either

implementing the Runnable interface or extending the Thread class. Separate the

classes into separate files. Do not leave all the classes in one file. Create a class for

each type of thread.

Add the following lines to all the threads you make:

public static long time = System.currentTimeMillis();

public void msg(String m) {

System.out.println("["+(System.currentTimeMillis()-time)+"] "+getName()+": "+m);

}

There should be printout messages indicating the execution interleaving. Whenever you

want to print something from that thread use: msg("some message here");

NAME YOUR THREADS or the above lines that were added would mean nothing.

Here's how the constructors could look like (you may use any variant of this as long as

each thread is unique and distinguishable):

// Default constructor

public RandomThread(int id) {

setName("RandomThread-" + id);

}

Design an OOP program. All thread-related tasks must be specified in their respective

classes, no class body should be empty.

DO NOT USE System.exit(0); the threads are supposed to terminate naturally by

running to the end of their run methods.

Javadoc is not required. Proper basic commenting explaining the program flow, selfexplanatory

variable names, correct whitespace and indentations are required.

Name your project as follows: LASTNAME_FIRSTNAME_CSXXX_PY

where LASTNAME is your last name, FIRSTNAME is your first name, XXX is your

course, and Y is the current project number.

For example: Fluture_Simina_CS344_p1

zip only the source files. Upload the project on BlackBoard.