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
}
}
