the assignment is about using multithreading for parallel programming. In the assignment folder you will find:
- zip file for examples of using Java Multithreading main functions.
- the pdf version of the assignment
Parallel Computing and Distributed Systems
Assignment 1 (10 points)
Question1 (parallel vs. sequential):
In this question, we need to measure the time difference between performing certain tasks sequentially and dividing and then
performing the same task in parallel. Create a class named STUDENT, that holds the student’s GPA (float value between 2.0 to
4.0), AGE (integer value between 18 to 30), and ID (unique integer value per student). For each of the following versions, calculate
(using Java.Time or the Java API you find appropriate) how long each version takes in seconds.
• Sequential version (Name this file as Q1_SeqV.java):
o Create a list of 50,000 students with randomly generated GPAs, randomly generated Ages, and sequential IDs.
o After creating the list, your program calculates and prints the average GPA and average AGE.
• Parallel version 1 (Name this file as Q1_PLV1.java):
o Repeat the sequential version using two threads along with the main thread.
o Each thread creates a list of 25,000 students with randomly generated GPAs, randomly generated Ages, and sequential IDs.
o Each of the two threads then calculates the average GPA and AGE (after creating the lists).
o The two threads work in parallel.
o The main thread waits for the two threads to finish and then calculates and prints the final average GPA and AGE from what
is reported by the individual threads.
• Parallel version 2 (Name this file as Q1_PLV2.java):
o Repeat the Parallel version1 task using five threads (each is working on 10000 students) along with the main thread.
To measure the time your computer takes to complete a certain task:
• Read and store the current time (t1) before you start the task (e.g., before creating the lists),
• After the task (e.g., after calculating the average), read and store the current time (t2).
• The time it takes your computer to complete the task is then: t2 – t1.
Question2 (Sorting):
In this question, we need to divide, sort, and merge a list of Employees using the multithreading framework. Create a class named
EMPLOYEE that holds the employee’s ID (integer value of unique value) and salary (integer value).
Step1: The main thread creates a list of 10,000 Employees with sequential IDs (1 to 10,000 to keep them unique) and randomly
generated salaries (between 1500 to 4000); name this list EmpList.
Step2: Split the generated list EmpList into two lists of equal length: List1, and List2.
Step3: Create two threads; each thread should sort the corresponding list (thread1 sorts List1, and thread2 sorts List2)
ascendingly with respect to the salary.
Step4: The main thread then waits for the two threads, then merge the two sorted sublists (List1 and List2) into the main list
(EmpList) ascendingly with respect to the salary.
Submission:
1. Use the IDE you find appropriate to develop your Java programs, and then create one PDF file where you list/copy the code
you developed for each question along with a screenshot for the outputs (of question 1 only).
2. Submit ONE ZIP/RAR file for the developed Java files and the PDF, named lastname_firstname.zip, directly to the folder
titled Assignment 1 under the D2L Assignments tab (other formats will not be accepted).
3. Check the due date on D2L. You can submit your assignment within 24 hours after this due date to be graded out of 50% of
the assignment’s grade. After this grace period, your late submission will not be accepted.
D_ThreadJoin.java
D_ThreadJoin.java
package
Threads_PC_341
;
public
class
D_ThreadJoin
{
public
static
Thread
thread1
;
public
static
Thread
thread2
;
public
static
void
function1
()
throws
InterruptedException
{
//———————–Thread 1 is running this function
for
(
int
i
=
0
;
i
<
5
;
i
++
)
{
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running"
);
}
}
public
static
void
function2
()
throws
InterruptedException
{
//-----------------------Thread 2 is running this function
thread1
.
join
();
// Wait for thread1 to finish first
//thread1.join(5000); // Waiting for 5 seconds for thread1 to finish
for
(
int
i
=
0
;
i
<
5
;
i
++
)
{
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running"
);
}
}
public
static
void
main
(
String
[]
args
)
throws
InterruptedException
{
/*
join(): is used to start one thread's execution to end of another thread's execution
such that thread B does not start running until thread A ends.
// 1st use: waits for thread A to die.
If any executing thread B calls join() on thread A (i.e; A.join())
Immediately B will enter into waiting state (blocked) until A completes its execution.
// 2nd use: waits at most this much milliseconds for thread A to die
join(long millis) method waits at most this much milliseconds for certain thread to die.
A timeout of 0 means to wait forever
Giving a timeout within join(), will make the join() effect to be nullified after the specific timeout.
*/
thread1
=
new
Thread
(
new
Runnable
()
{
public
void
run
()
{
try
{
function1
();
}
catch
(
InterruptedException
e
)
{
e
.
printStackTrace
();
}
}
}
);
thread1
.
setName
(
"first child"
);
thread2
=
new
Thread
(
new
Runnable
()
{
public
void
run
()
{
try
{
function2
();
}
catch
(
InterruptedException
e
)
{
e
.
printStackTrace
();
}
}
}
);
thread2
.
setName
(
"second child"
);
thread1
.
start
();
thread2
.
start
();
}
}
B_CreateSubThread.java
B_CreateSubThread.java
package
Threads_PC_341
;
public
class
B_CreateSubThread
{
public
static
void
function1
()
{
for
(
int
i
=
0
;
i
<
10
;
i
++
)
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running and value of i: "
+
i
);
}
public
static
void
function2
()
{
for
(
int
j
=
0
;
j
<
10
;
j
++
)
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running and value of j: "
+
j
);
}
public
static
void
main
(
String
[]
args
)
{
System
.
out
.
println
(
"Main thread and one child thread ..."
);
/*
* Within the main thread, we can now create more "child" thread, who can further create more "child" threads.
*/
Thread
thread1
=
new
Thread
(
//You give the Thread constructor some instance that implements the Runnable interface.
//Once started the Thread will call the Runnable instances run() method is a separate thread.
new
Runnable
()
{
public
void
run
()
{
function1
();
//assign function1 execution to thread1
}
}
);
thread1
.
setName
(
"Child thread"
);
//set a name for this newly created child thread
//-------------------Now lets run function1 in parallel with function2
//-------------------Run function1 on thread1
//-------------------Run Funciton2 on the main thread
thread1
.
start
();
//ask thread1 to run in parallel with the main thread
//, to execute the assigned function (function1)
function2
();
//run function2 on the main thread
}
}
__MACOSX/._B_CreateSubThread.java
C_KillThread.java
C_KillThread.java
package
Threads_PC_341
;
public
class
C_KillThread
{
public
static
void
function1
()
{
while
(
!
Thread
.
interrupted
())
{
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running"
);
//the interrupt cannot occur while sleeping, this will through exception.
//Thread.sleep(1000);
}
}
public
static
void
main
(
String
[]
args
)
throws
InterruptedException
{
/*
A thread is automatically destroyed when the run() method is completed.
But it might be required to kill/stop a thread before it completes its life cycle.
Using Thread.interrupt() method:
Whenever an interrupt is sent to a thread, it should stop whatever task it is performing.
*/
Thread
thread1
=
new
Thread
(
new
Runnable
()
{
public
void
run
()
{
function1
();
}
}
);
thread1
.
setName
(
"Thread 1"
);
thread1
.
start
();
Thread
.
sleep
(
2000
);
//Make the main thread sleep for 2 seconds
//In another word, let thread1 work for 2 seconds
//isAlive() tests if certain thread is alive (started and has not yet died).
System
.
out
.
println
(
"Is alive? "
+
thread1
.
isAlive
());
thread1
.
interrupt
();
Thread
.
sleep
(
5000
);
//Make the main thread sleep for 5 seconds
//In another word, give some time for thread1 to be terminated
System
.
out
.
println
(
"Exiting thread1"
);
System
.
out
.
println
(
"Is alive? "
+
thread1
.
isAlive
());
// Checks if this thread is alive
//continue the work of the main thread
System
.
out
.
println
(
"Exiting the main Thread"
);
}
}
A_MainThread.java
A_MainThread.java
package
Threads_PC_341
;
public
class
A_MainThread
{
public
static
void
function1
()
throws
InterruptedException
{
for
(
int
i
=
0
;
i
<
10
;
i
++
)
{
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running and value of i: "
+
i
);
Thread
.
sleep
(
100
);
//you can ask the current running thread to sleep (stop work) for number of milliseconds
}
}
public
static
void
function2
()
throws
InterruptedException
{
for
(
int
j
=
0
;
j
<
10
;
j
++
)
{
System
.
out
.
println
(
"Thread "
+
Thread
.
currentThread
().
getName
()
+
" is running and value of j: "
+
j
);
Thread
.
sleep
(
100
);
//you can ask the current running thread to sleep (stop work) for number of milliseconds
}
}
public
static
void
main
(
String
[]
args
)
throws
InterruptedException
{
// When a Java program starts up, one thread starts to run immediately - usually called the main thread of your process.
System
.
out
.
println
(
"Set/Get optional information about the Main Thread....."
);
//To access the current thread (e.g., to change the priority or name), you need to call Thread.currentThread()
Thread
.
currentThread
().
setName
(
"Our Main Thread"
);
System
.
out
.
println
(
"Main thread Name : "
+
Thread
.
currentThread
().
getName
());
System
.
out
.
println
(
"Sequential programming"
);
function1
();
//run function1 first by the main thread
Thread
.
sleep
(
1000
);
//you can ask the current running thread to sleep (stop work) for number of milliseconds
function2
();
//run function2 second by the main thread
Thread
.
sleep
(
1000
);
//you can ask the current running thread to sleep (stop work) for number of milliseconds
System
.
out
.
println
(
"Exiting the main Thread"
);
}
}
__MACOSX/._A_MainThread.java
E_ListsMaps.java
E_ListsMaps.java
package
Threads_PC_341
;
import
java
.
util
.
ArrayList
;
import
java
.
util
.
HashMap
;
public
class
E_ListsMaps
{
public
static
void
main
(
String
[]
args
)
{
ArrayList
<
Integer
>
myList
=
new
ArrayList
<
Integer
>
();
//create a dynamic list of integers
int
size
=
myList
.
size
();
//get the size of the list
myList
.
add
(
5
);
//add new integer element to the list
myList
.
add
(
6
);
//add new integer element to the list
myList
.
add
(
8
);
//add new integer element to the list
int
element
=
myList
.
get
(
1
);
//get the second element in the list
ArrayList
<
Integer
>
firstHalf
=
new
ArrayList
<>
(
myList
.
subList
(
0
,
2
));
//get sublist of myList: elements 0,1
HashMap
<
Integer
,
String
>
map
=
new
HashMap
<
Integer
,
String
>
();
map
.
put
(
100
,
“name1”
);
map
.
put
(
101
,
“name2”
);
map
.
put
(
102
,
“name2”
);
String
element1
=
map
.
get
(
100
);
//get value of this key
boolean
hasKey
=
map
.
containsKey
(
123
);
//check if this map contains such key
}
}
Order an Essay Now & Get These Features For Free:
Turnitin Report
Formatting
Title Page
Citation
Outline
