Parallel Comp and Dist Sys
Oluwatoyin
MultiThreading.zipD_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
}
}
