computing & concurrent system design

Concurrent Programming Design

Table of Contents

1.0 PROBLEM ANALYSIS.......................................................................................................3

2.0 REQUIREMENTS....................................................................................................................4

3.0 ASSUMPTIONS........................................................................................................................6

4.0 PROPOSED SOLUTION........................................................................................................12

5.0 DESGIN...................................................................................................................................13

5.1 Class Diagram......................................................................................................................13

6.0 PROGRAMMING TECNIQUES............................................................................................14

6..1 Design Patterns...................................................................................................................14

Singleton pattern....................................................................................................................14

Iterator pattern.......................................................................................................................15

Façade pattern........................................................................................................................16

6.2 Static keyword.....................................................................................................................18

6.3 Getters and Setters...............................................................................................................19

6. 4 Constructors........................................................................................................................19

6.5 MVC Architecture...............................................................................................................20

7.0 CONCURRENT PROGRAMMING CONCEPTS.................................................................21

7.1 Threads................................................................................................................................21

7.2 Thread Methods...................................................................................................................23

7.3 Synchronized methods.........................................................................................................23

7.4 Condition Synchronization and Thread communication.....................................................25

8.0 CONCURRET PROGRAMMING DESGIN..........................................................................28

9.0 TESTING & OUTPUT............................................................................................................32

10.0 SOURCE CODE LISTING...................................................................................................41

1


11.0 Depth discussion....................................................................................................................50

12.0 Critical appraisal....................................................................................................................52

13.0 REFERANCES......................................................................................................................55

2


1.0 PROBLEM ANALYSIS

Intention of this assignment is to develop a simulation application to represent the processes of

an airport by automating the all the task of the Air Traffic Controller. All the business operations

as an aircraft approaches an airport to leave the airport must be included in the simulation as real

world scenario.

Graphical representation of events is not required, but clear textual representations of describing

the events are expected from the implementation.

3


2.0 REQUIREMENTS

Automated the tasks of the air traffic control system. Such as assigning paths to the aircrafts,

perform takeoff, landing and holding pattern processes.

Air Traffic Controller (ATC) systems should responsible for perform main tasks as an

aircraft approaches an airport to leave the airport by completing every processes as quickly as

possible.

The air traffic simulation consists of airspace, one virtual path, two runways, hanger queue

and number of flights.

Aircraft does not collide with any other aircraft in any time.

Ensure that the approaching aircraft is inserted smoothly into the traffic around the airport

(around the controllers’ areas such as airspace, virtual path, runways and hanger areas).

Every aircraft insertion should be cause to minimum of disruption to the flight paths of other

aircrafts.

Airspace, virtual path and hangers will serve for each flight which as in the order of first-

come-first-serve manner in every time as possible.

FIFO rule should be break when special cases such as fuel problems, medical crises, aircraft

mechanical malfunctions and changing weather conditions, occur on flights. Those aircrafts

must be considered before than the other aircrafts.

Therefore prioritization process should be encounter throughout the life cycle of the air

traffic control system and updating should be done wherever as required.

One set of ATC responsible for assigning flight paths to incoming aircrafts.

Another ATC is responsible for guides those incoming aircrafts to holding patters or landing

approaches.

Another ATC is for guides flights to a safe landing.

4


Controllers always required communicating with each other and passing the handling of

aircrafts with details when required.

Each controller belongs to a specific frequency range.

Therefore pilots, operators and other controllers can identify each flight’s current responsible

controllers by switching the frequency.

Each controller should responsible for provide all the required details clearly for pilots,

operators and another controllers.

Since operators and pilots depend on those details rather watching the radar screen.

According to this scenario airspace, virtual path. Runways and hangers should be the shared

resources.

5


3.0 ASSUMPTIONS

This application will be representing an existing airport to make a simulation more realistic.

Therefore at the beginning virtual path and hangers will be loaded with five flights and

random number of flights (the range of 0 - 12) will arrive to the air space at once. In other

words virtual path and hanger queues are already filled with five aircrafts and some numbers

of flights are arriving in to the airspace after authenticated by the proposed airport’s

simulators at the beginning of the application. Therefore existing flights of virtual path and

hanger queues are considered before any other aircrafts in any case of this application by

assuming those flights are waiting long time than newly arrived aircrafts).

This air traffic control system is fully automated and does not need any user input to

performed tasks (all the required details are generated and retrieve by the sub controllers

within the system).

This air traffic control system only needed the proposed airport processes and do not consider

and communicate with other airports’ air traffic simulators. Therefore the following

processes will not considering in this application

Communicate with the air traffic control systems that reached by the flights which

request for land at the represented airport.

Communicate with the neighbor air traffic control systems to guide the flights which

request for reach the distance of the proposed airport.

After arriving to the airspace by completing the takeoff process.

Whole air traffic control processes will be handling by four air traffic simulators. Those are

called as air space controller, virtual path controller, runway controller and hanger

controller. As same as the name implies all the controllers are responsible for handling

traffic around their corresponding areas (such as air space controller is responsible for

handling air traffic around the airspace).

6


Airspace controller is responsible for authenticating the flights within the range of the

airport, assigning path to flights which request for landing at the proposed airport, assigning

path to flights which request for reach the distance of the airport, guided those flights until

reach the controller area on assigned path, check emergency flights, check flights required to

move on to the virtual path, provide the flight path details to hanger controller to perform the

takeoff, set priorities according to the flights status and hand over the handling to next

controller of a particular flight with details when required.

Virtual path controller is responsible for authenticating flights which request to arrive into

the virtual path, assigning path for those flights, guided those flights until reach the controller

area on assigned path, check availability in virtual path, provide the virtual path details to

airspace controller, check emergency flights, check flights required to land, set priorities

according to the flights status and hand over the handling to next controller of a particular

flight with details when required.

Runway controller is responsible for guide assigned aircraft on to an assigned runway,

check runway availability, clear the runway as soon as possible when complete the takeoff

process or landing process and provide the runway details to hanger controller and virtual

path controller.

Hanger controller is responsible for guide the aircrafts on to an assigned hanger queue,

provide the hanger details to virtual path controller, check availability in hanger queues,

check and set the priorities of flights, check flights required to takeoff and provide the takeoff

flights details to the airspace controller.

Controllers are always communicating with each other and provide the handling responsible

for next controller when aircraft is needed to reach one controller area to another controller

area by authenticating specific aircraft with its details.

This airport has only one virtual path and two runways.

7


To make the simulation easy to understand, flights are named with their responsible areas.

Such as airspace flights are named as “AF”, virtual path flights are named as “VF” and

hanger flights are named as “HF”. Moreover one flight ID will not use again and again. (i.e.

after flight AF1 is successfully complete the takeoff process flight ID AF1 will not appear

again).

The actual time line is not considering in this application and flights are move around

without any delay of time.

The spaces between flights are do not cause to occur any aircraft collisions.

Airspace is conceptually divided in to paths using altitude, direction and the path range of 20

units such as 0-20, 21-40. Those paths will be assigning for flights which use the represented

airspace and one path will assign only for one flight and path range unit will be not

exceeding the upper bound number.

Airspace can be used for flights which required to land at the represented airport, required to

reach the distance of the airspace and takeoff flights. Different altitude paths (5000ft paths

are assigned for landing flights, 8000ft paths are assigned for reaching / not landing flights

and 3000ft paths are assigned for takeoff flights) are used to avoid aircraft collisions between

those flights.

All the aircrafts belongs to airspace controller area required to switch on the frequency range

of 6000Hz – 6500Hz. Therefore pilots, operators and other controllers can identify each

flight’s current responsible controller by switching the frequency.

All the airspace flights are guided and move around only on assigned path.

The flights will not meet with any disruption during the way of airspace to virtual path.

Any number of flights can be arriving to the airspace.

8


Virtual path and hanger queues are capable of handling a maximum of 10 flights.

Virtual path is also conceptually divided in to ten positions / paths and those are indicated

using numbers (0 - 9).

All the aircrafts belongs to virtual path controller area required to switch on the frequency

range of 5000Hz – 5500Hz. Therefore pilots, operators and other controllers can identify

each flight’s current responsible controller by switching the frequency.

One position will only assigned for one flight at a time to avoid aircraft collisions in virtual

path.

All the virtual path flights are guided and move around only on assigned path.

Virtual path is used for sorting purpose. In other words virtual path is used to handle flights

until prioritization and landing processes will complete.

The flights will not meet with any disruption during the way of virtual path to runway.

Both runways are used to perform takeoff and landing processes.

All the aircrafts belongs to runway controller area required to switch on the frequency range



Once complete the takeoff process (after release the runway) the flights will not meet with

any disruption until arrive to the airspace.

Once complete the landing process (after release the runway) the flights will not meet with

any disruption until reach to the hanger queue.

Hanger queues are labeled using numbers (0 - 9).

9


Hangers will be assigned at the virtual path for landing flights to avoid aircraft delay of time

and one queue will issue only for one flight to avoid aircraft collisions in the hangers.

All the aircrafts belongs to hanger controller area required to switch on the frequency range



Successfully complete the landing process once, the flights are quickly move to the assigned

queue without any delay and clean the runway for next flight to perform the task.

Every special case such as fuel problems, medical crises, changing weather conditions and

aircraft mechanical malfunctions are consider as the same status and provide highest priority

for those aircrafts. If there are more than one emergency case occurred in any given time,

priority will be assigned based on the FIFO (First In First Out) pattern.

Since proposed air traffic simulators represent the existing airport, the virtual path existing

emergency aircrafts will be considering first. (By assuming those flights are waiting long

time than newly arrived aircrafts).

Emergency flights are handling quickly as possible.

Flights are stop in the hanger queues according to the order. Such as the hanger queue

number 0 is assigned for the firstly arrived flight and next queue for the next flight.

Since proposed air traffic simulators represent the existing airport, random waiting time will

assign for existing virtual path flights as a solution to the priority problem at the beginning.

Therefore value with highest waiting time is the flight that waits for a long time and required

to be assigned as highest priority flight (after the emergency flights).

The firstly arrived flight in to the airspace is the flight that required to be assigned as highest

priority flight (after the emergency flights).

10


User manual will helpful for the operators since they don’t have much knowledge of the

computer based system and fully automated system.

Operators are not need to input any details and manual decisions do not affect (and reflect) to

the proposed system.

4.0 PROPOSED SOLUTION

Solution to above stated problem should be providing using appropriate concurrent program

design concepts and methods using Java language (according to the requirement specified in the

11


assignment). In other words simulation should be representing the concurrent access of flights

and controllers as the real world scenario. Object oriented concepts of Java language can be used

in order to satisfy the appropriateness of the implementation.

The solution design is described with the structured and class diagrams, FSPs, LTSs and those

explanations are described in the following chapters.

12


5.0 DESGIN

5.1 Class Diagram

13


5.2 Structure Diagram

14


6.0 PROGRAMMING TECNIQUES

6..1 Design Patterns

The following design patterns were used for the implementation of the Air Traffic Control

system design.

Singleton pattern

Singleton pattern was used since only one instance of the classes was required in the

implementation. Because of according to (Gamma, E. et al. 1999) the singleton pattern ensures

that a class has only one instance and provides a global point of (public) reference to that

instance.

E.g.:

(Note: only the relevant code to demonstrate pattern is listed)

This concept were used in all the classes including the classes which holding the shared

resources. Above code example was used to create a singleton instance for air space controller

class. Since other controller classes required to access the information of airspace controller class

and those are threads it is must require using one instance in everywhere.

15


Iterator pattern

As described by the (Gamma, E. et al. 1999: P.23 – P. 24) iterator provides ways to access

elements of object member by sequential manner without exposing to the underlying structure of

the object.

Hanger queue class used an array list to hold the flights which are in the hanger queues. Hanger

controller class access that queue to get the details of flights which is stop at those hanger

queues. (All the other shared resources such as airspace and virtual path used the same concept

and all the ATC controllers were accessing those array lists to retrieve the flight details). Since

controllers are iterate through the queue to retrieve specific flight details until reach the size of

the array list. Iterator pattern’s concept is directly used the java iterator. In proposed system

implementation used several iterators to retrieve the aircrafts details.

E.g.:


16


Façade pattern

According to (Gamma, E. et al. 1999: P.15 – P. 16) façade defines a unified, higher level

interface to a subsystem to make it easier to use. In the given scenario Air Traffic Controllers are

responsible to perform as coordinators between the shared resources (airspace, virtual path,

runways and hanger queues) and aircrafts. In other words Air Traffic Controllers are act as a

façade or unified interface to each of the flight involve in the system. Therefore flights do not

required to direct contact with the shared resource details is the major advantage of this pattern.

Since controllers can handle all the resources (shared resources and aircrafts) is caused to

increase the efficiency of the concurrent execution.

E.g.: the method public synchronized boolean check_availability_in_virtualPath () {}

Is used to check the availability status on the virtual path and implemented within the

airspace controller class.

When flight is request to move on to virtual path, airspace controller will check with this method

and pass the details to the requested flight.

17


E.g.:


\

18


6.2 Static keyword

When considering the requirements of the given scenario, should be able to retrieve the specific

aircraft details from any responsible ATC controller class. As an example when flight required

moving to virtual path, it must have the same details of that particular flight in the virtual path

controller class as same as in the airspace controller class. Static keyword used to accomplish

this task.

In this implemented code used static keyword for class members which required to be used

independently of any object of that class. Also it provides the advantage of accessing particular

class member before any objects of its class are created.

E.g.:

Static variable is used for flight ID since those are required to be specific. Therefore all the

classes are shared the same static variable for the flight ID.

E.g.:

(Note: only the relevant code to demonstrate above is listed)

19


6.3 Getters and Setters

This is one of the Object Oriented concepts called data hiding. Data hiding is used to provide the

authority access (specially used for private modifier) between methods and classes.

Implementation for the given scenario used this concept to secure the shared resource access. In

other words limit the access for shared resources by placing private access modifier. Since used

the public getters and setters for access those shared resources.

E.g.:

6. 4 Constructors

At the time of creating flights it should require identifying each one specifically. Therefore

constructor of flights class used to define the each flight’s ID and emergency status as those are

major requirements of this ATC system.

E.g.:

20


6.5 MVC Architecture

This implementation was done according to the MVC architecture. As described by the (Gamma,

E. et al. 1999: P.14) MVC consists of three kinds of objects. Those are Model, View and the

controller. The model is the application object, the view is its screen representation and the

controller places in between of model and view by controlling those.

According to the implementation of the ATC, it used shared resource classes as model objects

such as airspace queue, virtual path queue, runways and hangers queue. Also used user

manual and ATC_view classes as view objects and controller classes such as airspace

controller, virtual path controller, runway controller and hanger controller as controller

objects.

E.g.: model objects (classes)

View objects (classes)

Controller objects (classes)

21


7.0 CONCURRENT PROGRAMMING CONCEPTS

7.1 Threads

According to (Meyer, B. et al 2010: P.5) Creating a thread is the base for concurrency. To

achieve it more efficiently can create threads for the objects in the application which required

executing concurrently. Therefore several thread instances were used in this application. As

described by the (Meyer, B. et al 2010: P.5) as same as every java program consists of at least

one thread which executes the main () method, proposed solution also used main thread is the

thread which resulted in starting the execution of whole program. It could achieve by using,

According to the (developperWorks, nd: P.4) though there are two ways of implementing

concurrency by implementing runnable Interface and extending from Thread class, proposed

solution uses the second way (extending from Thread class) throughout the implementation to

create concurrency.

E.g.:

As described by the (Meyer, B. et al 2010: P.5) after inherit from the thread class, should

override the run () method to complete the process. Run () is the most important part of the

Thread implementation since all the functionalities must include within that (Costa, P. nd: P.7).

E.g.:

To run the thread must invoke the start () method on the run () of the object (Meyer, B. et al

2010: P.6).

22


Eg:


According to above stated features, thread representation of the proposed solution is as follows.

23


7.2 Thread Methods

As described by the (developperWorks, nd: P.10) the sleep () causes the current thread to sleep

for a specified amount of time in milliseconds. This method is mainly used in this application to

increase the readability of the textual outputs.

E.g.:

7.3 Synchronized methods

Running more than one thread inside the same application does not provide any problems. The

problems can occur when trying to access the same data and resources by multiple threads at the

same time (Meyer, B. et al 2010: P.9). Furthermore read the same data and resources by multiple

threads does not arise any problem at all. In other words reading the shared data by multiple

threads at the same time is thread safe (code that is safe to call by multiple threads

simultaneously) process. Problems only arise if one or more of the threads try to write / change

to these resources. Without any proper solution to this problem is leads to occurring “race

condition and critical section” (developperWorks, nd: P.24).

As described by the (Meyer, B. et al 2010) only the shared resources are cause to occurring race

conditions in multi-threaded environment. When considering the code implementation following

resources do not shared by the threads.

Local variables

E.g.:


24


Local object references

E.g.:


But following resources are shared by the threads in the code implementation.

Object members

Methods of the classes / object instances

Most of the object members are public to all other external threads. Therefore those object

members are not threaded safe.

(There is no any risky object member in the proposed implementation).

According to (Meyer, B. et al 2010: P.9) and (developperWorks, nd: P.30) this problem can be

avoid using the concept of “synchronization”. Synchronization is the process will ensure that

only one thread can access the data at one time. To achieve that it uses the lock of the object.

Synchronization will locked the one thread at a time and others have to wait until complete the

task. This called as “mutual exclusion”.

As described by the (Meyer, B. et al 2010: P.9) though java provide two ways to achieve mutual

exclusion via synchronization as synchronized methods and synchronized block, this

implementation used the synchronized methods only.

25


All the ATC controller classes are used synchronized methods since those are used shared

resources.

E.g.: Air space controller class has following synchronized methods.

7.4 Condition Synchronization and Thread communication

When required to execute a block of code continuously or until reach some condition, the

condition synchronization can be used. It benefits to stay inside the loop until satisfy the task.

E.g.:

Most of the time when accessing the condition synchronization it must requires performing inter-

thread communication to complete the tasks (Jennery, K. B., 2003: P.52). Java highly supports to

achieve inter-thread communication by enabling some methods (Meyer, B. et al 2010: P.10).

Those are as follows.

26


Wait ()

As described by the (Schmidt, D.C. nd: P.35 - P.36) wait () result in following actions.

The current thread is suspended

Waits for a condition to be satisfied.

Release the synchronization lock associated with the monitor object.

Wait () method is used to perform inter-thread communication in implemented code.

E.g.:


After perform the main task of the above method wait () call gets executed. Then current thread

state become blocked and releases the lock and provides handling to another thread to execute on

this method.

To increase the accuracy of the mutual exclusion, customized wait () method is used

E.g.:

27


Notify ()

As described by the (Meyer, B. et al 2010: P.11) wakes up a single thread that is waiting on this

object’s set. When particular thread is awakened, still it cannot require the lock until the previous

method releases the lock. The weak point of notify () is to developer do not know which thread

will wake up. But this method used in this application by customizing notify () method.

E.g.:


In this method notify a waiting thread vpc (virtual path controller) but does not yet release the

lock of the current object. However eventually the current thread will release the lock by leaving

the synchronized block, unblocked vpc thread can acquire the lock of the method.

28


8.0 CONCURRET PROGRAMMING DESGIN

8.1 Finite State Process (FSP)

Landing process

FLIGHT_LANDING=(hanger_available -> runway_available->(runway_one ->

assign_runway_one->assign_hanger_queue->landing-leave_runway_one-

stop_in_hanger_queue ->FLIGHT_LANDING

|runway_two -> assign_runway_two ->assign_hanger_queue->landing-

leave_runway_two->stop_in_hanger_queue ->FLIGHT_LANDING

|runways_busy ->waitng_in_virtualPath -

>FLIGHT_LANDING

|hangers_busy -> waitng_in_virtualPath ->FLIGHT_LANDING)).

Takeoff process

FLIGHT_TAKEOFF =(runway_available->(runway_one -> assign_runway_one-> takeOff->

leave_runway_one->arrive_to_airspace -> FLIGHT_TAKEOFF

29


|runway_two -> assign_runway_two ->takeOff->leave_runway_two-

arrive_to_airspace->FLIGHT_TAKEOFF

|runways_busy ->waitng_in_hanger_queue ->FLIGHT_TAKEOFF)).

30


8.2 Label Transition Systems (LTS)

Landing process

31


Takeoff process

32


9.0 TESTING & OUTPUT

Event Success

Random number of (up to 12) flights are add once to the airspace

Five number of flights are add once (existing flights) to the virtual path

Sort the virtual flights according to the waiting time

Five number of flights are add once (existing flights) to the hangers

Flights enter airspace (newly created) at regular intervals

Flights IDs are statically create (flight IDs are unique)

Emergency status of flights are randomly generated

Altitude of flights are randomly generated x

Frequencies are auto generated x

Direction of flights are randomly generated

Flights which required to reach the distance of the airport are created and

display

Delete reaching flights after displaying from the airspace queue class.

33


Check emergency flights in the virtual path (store emergency flights in

temporary list)

Display “Currently there are no any emergency flights in virtual path” if no

any emergency flights.

Check emergency flights in the airspace (store emergency flights in

temporary list)

Display “Currently there are no any emergency flights in airspace” if no any

emergency flights.

Correctly assign hanger queues for virtual emergency flights

Correctly assign runways for virtual emergency flights

Virtual emergency flights will waiting until clear a runway (if runways are

busy)

Virtual emergency flights will waiting until clear a hanger queues (if hanger

queues are busy)

Assign virtual path slots for airspace emergency flights (add those

emergency flight into beginning of the virtual path array list)

airspace emergency flights will waiting until clear a position (if virtual path

is busy)

Virtual path flights which assigned the hanger queue and runway are

stopped at the correct hanger queue number

34


Airspace flights which assigned the virtual positions are moved on correct

position

Assignment of runway is done correctly (one runways is assign only for one

flight at a time).

After arriving to the virtual path, airspace emergency flights are store in

same array list, but behave independently.

All the virtual path flights consider before considering airspace flights

Correctly assign hanger queues for airspace emergency flights

Correctly assign runways for airspace emergency flights

FIFO will considering when normal flight prioritization process

Correctly assign hanger queues for high priority virtual flights

Correctly assign runways for high priority virtual flights

After arriving to the virtual path, airspace flights are store in same array list

but behave independently.

Flights which move from airspace are add at the end of the virtual path array

list

Correctly assign hanger queues for high priority airspace flights

35


Correctly assign runways for high priority airspace flights

Each array list moves forward

Iterators work properly

After flight approaches the airport, it will complete all the processes before

complete the takeoff process

Takeoff will satisfy the conditions x

Takeoff will be perform continuously x

Takeoff and landing processes can be performed at once x

The static test is performed x

Application will running continuously (for the simulation purpose ) x

36


9.1 Sample output

User manual

37


Airspace controller

38


ATC View

39


Virtual path controller

40


Hanger controller

41


10.0 SOURCE CODE LISTING

Following discussed the methods with the code example which run according to the flow of the

system.

At the beginning of the application ATC_GUI class gets executed. It holds the link to the

User_Manual GUI class and the User_manual_previw class.

User_manual_previw is the startup thread. It includes the instruction details of the ATC system

in the run () and run on the User_Manual GUI.

Before end of the run () method of User_manual_previw, included the start () methods of

Air_sapce_controller, Virtual_path_controller, Runway_controller and Hanger_controller

42


thread instances. Therefore after executing the User_manual_previw instruction, all the

controllers’ threads are starting to run. At the same time User_Manual GUI become invisible and

ATC_GUI become visible to the user.

At the beginning of the application required to represent some aircrafts around the airport since

the designed ATC system represents the existing airport. ATC_view is a thread class and it

provides the data sets for all controller classes to achieve the simulation purpose. Those methods

are as follows.

The following add_flights_to_airSpace () method create random number of flights (up to 12) at

once and add to the airspace at the beginning (to represent the some number of flights arriving at

the first stage of the application).

43


The add_flights_to_virtual () method which is in the ATC_view class, add five aircrafts to the

virtual path at the beginning. ATC_view class has method call add_flights_to_hanger () which

same as the add_flights_to_virtual () to add five aircrafts to the hanger queue at the beginning.

Adding flights in to airspace, virtual path and hangers will be happen in parallel.

Create new flights at regular intervals using add_flights () method which is in ATC_view class

until close the application. This method used the keyword “synchronized” because, when flight

is complete the takeoff process it should be display in the airspace before leave the airport.

Therefore both methods add flights to the airspace queue (takeoff method and add_flights

method) since both are thread instance, it should be ensure to avoid the race conditions.

44


After adding the (existing) flights in to controller areas, airspace and virtual path controllers are

responsible to check the emergency flights and provide the priority for each flight by checking

flight details. Airspace controller check the emergency flights by using

check_emergency_flights_in_airSpace () method and it used “synchronized” because it try to

add flights to the virtual path. At the same time virtual path controller will check for the

emergency flights which is in the virtual path by using check_emergency_flights_in_virtualPath

() method.

45


After checking emergency flights in the airspace, airspace controller thread will wait until virtual

path emergency flights land. Within the direct_emegency_flights_from_virtualPath_to_runway

() method both hanger queue and runway will assign for emergency flights. Emergency flights

have to wait either runway or hanger queue will not be available at that time. This method used

synchronization since it accesses the runways (shared resources).

At the beginning runway controller thread forced to wait since there is no any flight checked to

perform landing process. Therefore after completing the execution of

direct_emegency_flights_from_virtualPath_to_runway () method (after checking all the

emergency flights in the virtual path) will inform to the runway controller to perform its task.

After notifying the runway controller it will give chance to the

46


direct_virtual_emegency_flights_from_runway_to_hanger () method to complete the landing

process.

After successfully completing the landing process of the virtual emergency flights, runway

controller handover the control to the virtual path controller.

direct_emegency_flights_from_airSpace_to_runway () method of the virtual path controller will

follow the same process as same as the

direct_virtual_emegency_flights_from_runway_to_hanger () method to direct the flights with

emergency that occur in the airspace to the runways. This method used the synchronization since

it accesses the shared resources. To complete the landing process virtual path controller will

hand over the control to runway controller.

direct_airSpace_emegency_flights_from_runway_to_hanger () method follow the same process

as same as the direct_virtual_emegency_flights_from_runway_to_hanger () method to direct

those emergency flights to hanger queues. After successfully completing the landing process

runway controller will hand over the control again to the virtual path controller.

47


The method check_flights_need_to_move_runway () will check virtual path flight priorities

(without emergency) to identifying the flights which required to land.

After checking priorities of the virtual path flights hand over the control to airspace controller by

waiting virtual path controller until gets informed. Then airspace controller’s

check_flights_need_to_move_virtualPath () method follow the same process to check flight

priorities of airspace flights. It used the synchronization since it access the virtual path.

48


After complete the flight prioritization in the airspace, it will notify the virtual path controller by

handing over the control. Then virtual path controller’s

direct_normal_flights_from_virtualPath_to_runway () method assign the virtual flights which get

high priority (flights with highest waiting time) to runways and hangers in order to perform the

landing process.

49


When taking the control from virtual path controller, runway controller performs the landing

process. direct_virtual_normal_flights_from_runway_to_hanger () method used to do that task.

Then again handover the control to virtual path controller to direct the highest priority flights

which was in the airspace. It can be done by using virtual path controller’s

direct_normal_flights_from_airSpace_to_runway () method. Then it follow the same process as

same as the direct_virtual_normal_flights_from_runway_to_hanger () method.

50


11.0 Depth discussion

When reevaluating the requirements of the given scenario I could achieve most of them. The

basic requirement was to automating the ATC system with major processes. I have designed my

ATC system as fully automated without interacted any user inputs. All the required details are

generated according to the current situation and communicate through the controller class.

Therefore I could achieve the basic requirement of this assignment as some extent.

Also the requirements will expect to perform major tasks of the airport. In my system I have

designed aircraft arrivals, move to virtual path, assigning runways and hangers with landing

process. Most of the tasks are execute as parallel processes. But I was unable to properly code

takeoff process because it interrupted the flow of the other processes. I have tried to apply

separate monitor object to performed takeoff process. But it caused to occurred deadlock

situation due to sharing runways with landing processes. Therefore I’m unable to perform take

off as expecting the scenario. But I have developed to performed takeoff at the end of the all the

other processes.

I was unable to consider about the changes of weather conditions. I was only considering about

other emergency situations that stated in the requirements. When bad weather occurred, it will

affect for all flights in the airport. Without using (since the given problem ask not to use)

thread.stop() or thread.interrupted() it was more difficult to handle that situation.

I have included the one airspace, one virtual path, two runways and ten hanger queues as

expected by the given scenario. Also I have added additional conditions such as virtual path can

be hold maximum of ten flights, only ten hanger queues are available at a time and any number

of flights can be arrived to airspace, to increase the performance of the system.

I have ensure the aircrafts are does not collide in any time by handling those proper way. I have

checked the virtual path availability in my airspace controller class to avoid the collisions and

delay of time. And check the availability in hangers, runways and assigning those are done in the

virtual path controller. Furthermore I have ensure the aircrafts are does not collide in any time by

displaying specific flight only in one specific controller area at a time. Also to increase the

51


security I have provide specific flight IDs to each aircrafts at the beginning and those are not use

again and again.

As stated in the assumptions I have ensure the aircrafts are inserted smoothly into the traffic

around the airport by giving specific paths and positions in the airspace and the virtual path.

(More details are in the assumptions section). (Only need to worry those two areas due to

moving large number of flights around. Runways areas and hangers’ areas have less number of

flights).

As expected in the requirements I have provide the proper prioritization process in each

controller class. Since I have designed existing airport I have provided high priority to virtual

path emergency flights, then airspace emergency and then the normal flights. When processing

prioritization for normal flights, I have used the FIFO pattern and I have broken the rules only in

emergency situation.

Finally I have not provided continuously execution of the system due to simplified the

simulation.

When considering the requirements and the implementation of the designed system I believe I

could achieve most of those.

52


12.0 Critical appraisal

Since the given problem expected to automate ATC system, first of all I had to learn the real

world ATC systems. At the beginning I couldn’t understand most of the requirements that stated

in the scenario. After researching some real world systems, I gained the basic knowledge about

the ATC system. Also it was quite hard to implementing the concurrency concept in a standalone

application with ensuring the concurrent requirements. Since Java provide highly flexible

environment for implementing concurrency it was reduce the complexity of the problem.

The modeling techniques that required using in this scenario were LTS and FSP which I had

never learned before. Therefore it was also quite hard to learn since more resources not available.

However when the time of implementing the system I have learned most of the concurrent

concepts and how to apply those. The above stated chapters explained those concepts and code

examples that applied by the system.

I liked to state some statements here about the concurrent concepts which I did not use in my

implementation and reasons for those.

Runnable Interface

According to (Costa, P. nd) there is little difference between the implementation of threads

using the two approaches even doing the same thing in the threading API. As moreover

explained by the (Costa, P. nd) by extending the thread class, the derived class itself is a

thread object and it gains full control over the thread life cycle. When implementing the

runnable interface class does not provide any control over the thread itself. Since java does

not support for multiple inheritance extending the thread class eliminate the chance for

inherit from any other class. It does not occur when implementing runnable interface.

Because of using implementation, there is a chance to extending from another class. But for

proposed solution does not use any other inheritance rather than the thread class. Also it

highly used thread states such as start (), wait (), notify (), sleep () to control the thread

execution. When considering above reasons, the approach of extending from the thread class

is more suitable for proposed solution.

Thread priority

53


According to the (Meyer, B. et al 2010) thread priority can be used for assigning order for

threads. But as explained by the (developperWorks, nd: P.9) this is not guarantee. Therefore

this implementation does not use thread priority (only use the default priority value 5).

Thread methods

Following thread methods are do not use in the implementation

o Yield () causes the current thread to move from the running state to runnable state.

o Interrupted () force to thread to change

o Suspend () suspend the thread

o Stop () terminate the thread

Those are force to change the thread states and interrupt to the execution flow of the

application. Also may cause to loss or corrupt the data. Therefore those were not applied in

this proposed solution.

Synchronization block

As described by the (Costa, P. nd: P.18) synchronized blocks can be used to lock current

thread as well as the any given thread by taking as argument of which object to lock. But

synchronized methods can be used to lock the current thread. According to (Schmidt, D.C.

nd: P.32 - P.34) in Java, block synchronization is considered to be a more basic construct

than method synchronization. Because of only the shared resource is lock by the method

block. It is rather risky than method block. Therefore in the proposed solution

implementations used only synchronize methods.

54


notifyAll ()

This method wakes up all threads that are in waiting mode (Costa, P. nd: P.58). Therefore

this not used in implementation of the proposed solution due to increase the accuracy of

mutual exclision.

Finally this was good start for concurrent programming and was quite interesting programming

period by created an interest in me about the concurrent environment. However there are still a

lot more in concurrent programming that still remains to be explored.

55


13.0 REFERANCES

Aldrich, J. (2005). Design patterns. [Online] available from: http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=2&ved=0CF4QFjAB&url=http%3A%2F

%2Fwww.cs.cmu.edu%2F~aldrich%2F214%2Fslides-aldrich%2F11-design-

patterns.pdf&ei=1IbMT-

r3O8SmrAeG8ayeDg&usg=AFQjCNGbowXe0KmGpa6JxWWzggL1x8YOwg&sig2=PQCri4O

y-zFMox32JJ1CWA. [Accessed 1/06/2012].

Costa, P. (nd). Concurrent programming in java. .[Online] available from:

http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CE4QFjAA&url=http%3A%2F

%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fdownload%3Fdoi%3D10.1.1.187.6218%26rep

%3Drep1%26type%3Dpdf&ei=5VDLT-avGo-

JrAeF1oHRDg&usg=AFQjCNG_uIvIhsEooAxic4hwj0R6gLEOEw&sig2=WQLDrIQ8NItmnwq

3IPy3rQ. [Accessed 31/05/2012].

developperWorks, (nd). Concurrent programming in the Java language. .[Online] available

from: http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CFAQFjAA&url=http%3A%2F

%2Fcarfield.com.hk%2Fdocument%2Fjava%2Ftutorial%2FThread

%2FAdvance_thread.pdf&ei=4UPLT56QF8nlrAfa-4nBDg&usg=AFQjCNHuzXCE-

AzllnPKL9KZtdAYTqEGkQ&sig2=7Hu1m_aC4mEbG6Y2Eug1Vw. [Accessed 31/05/2012].

Gallardo, D. (nd). Java design patterns.[Online] available from: https://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=2&ved=0CFQQFjAB&url=https%3A%2F

%2Fwww6.software.ibm.com%2Fdeveloperworks%2Feducation%2Fj-patterns%2Fj-patterns-

ltr.pdf&ei=FmXMT577PIaHrAfv9uCfDg&usg=AFQjCNF1xNHJYH7wuqdiV1fOTKy9lGaX-

A&sig2=QMON-GFssV7M2nKJHyY_Ew. [Accessed 1/06/2012].

Gamma, E., Helm, R., Johnson, R. (1999). Design patterns elements of reusable Object Oriented

software. [Online] available from: http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CFwQFjAA&url=http%3A%2F

56


%2Fwww.uml.org.cn%2Fc%2B%2B%2Fpdf

%2FDesignPatterns.pdf&ei=n2nMT_CGIYjxrQeY3rmvDg&usg=AFQjCNEwKV3ToLmt85RL

31y52Vrc6fKJ0Q&sig2=D7l9rJ7FmTF6i-Do1Oijnw. [Accessed 1/06/2012].

Jennery, K. B., (2003). Multi-Threaded concurrency in Java.SunMicrosystems. .[Online]

available from: http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CFUQFjAA&url=http%3A%2F

%2Fwww.softwaresummit.com%2F2003%2Fspeakers

%2FJenneryMultithreading.pdf&ei=fDXMT9GbL4jNrQe4y4mfDg&usg=AFQjCNH4cEnHT2T

_ZCP4_bXnt8_QsonX1w&sig2=Qf71ctTwmYhCzTcEtdwG5A. [Accessed 1/06/2012].

Meyer, B., Pedroni, M. (2010). Concurrent Programming with Java Threads.[Online] available

from: http://www.google.lk/url?

sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CE8QFjAA&url=http%3A%2F

%2Fse.inf.ethz.ch%2Fold%2Fteaching%2F2010-S%2F0050%2Fslides

%2F13_softarch_self_study_threads.pdf&ei=l0DLT7OUC4rZrQfE3IC2Dg&usg=AFQjCNFAf6

h8eludGb-tYJo9K2VRH7g2XQ&sig2=THojGGqkZvdSBOW9fWa42g. [Accessed 31/05/2012].

Schmidt, D.C. (nd). Concurrent programming with Java. .[Online] available

from:http://scm0329.googlecode.com/svn-history/r130/trunk/book/concurrentprogramming.pdf.

[Accessed 1/06/2012].

57

computing & concurrent system design

Documents