Java threads

Thread Creation 
There are two ways to create a thread.

1. Extend the java.lang.Thread class.
2. Implement the java.lang.Runnable interface.

Thread states

 A thread can be in one of the following states:

  • A thread that has not yet started is in this state.
  • A thread executing in the Java virtual machine is in this state.
  • A thread that is blocked waiting for a monitor lock is in this state.
  • A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
  • A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
  • A thread that has exited is in this state.


A thread can be in only one state at a given point in time. These states are virtual machine states which do not reflect any operating system thread states.

Note:The values that represent these states are encapsulated in the java.lang.Thread.State enum.

Thread synchronization
 java provides built-in locking mechanism for securing exclusive access to an object through the synchronized modifier. java also provides Concurrency Utilities which include better locks. so whenever possible we should these locks.

Following are two mechanisms which use synchronized modifier to write thread safe code-

Method Synchronization
Every Java object has an intrinsic lock. To acquire an object's intrinsic lock is the same as locking the object. When we use the synchronized modifier for a method then we basically lock the object for the current thread. no other thread can access the method or any other synchronized method on the object.  this is object level locking. if the method is static the lock is applicable at class level , which means, no other thread can access any synchronized method of any object of the class.

Block Synchronization
Synchronizing a method is not always possible for various reasons. for example we may not have access to the source code of the class. Java allows us to lock any object through block synchronization. Its syntax is this -
synchronized(object) {
    // do something while locking the object
}
On other note, method synchronization is the same as block synchronization that locks the current object:
synchronized(this) {
    ...
}

Visibility

Due to the memory model in Java, a thread may not see changes made by another thread unless the operations that act on the data are synchronized. To solve this problem a variable can be declared as volatile.





Location: Bengaluru, Karnataka 560001, India

Comments

Post a Comment

Popular posts from this blog

Palindrome program in Java using BufferedReader

import java.io.*; class Test { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.print("\nEnter a String : "); String str = br.readLine(); String rev = ""; int n = str.length(); for(int i=n-1 ; i>=0 ; i--) { rev = rev + str.charAt(i); } if(str.equals(rev)) System.out.println("\nGiven string is a palindrome"); else System.out.println("\nGiven string is not a palindrome"); } } Output 1 Enter a String : ABCDDCBA Given string is a palindrome Output 2 Enter a String : abcdabcd Given string is not a palindrome
Read more
Generics Array Java does not permit the construction of generic array. Suppose, for example, that we want to design a class that has an array field public class Table<AnyType> { private AnyType[] contents = new AnyType[5]; ... } It's hard to understand, but this is illegal! A workaround is to construct an array of objects with a type-cast: public class Table<AnyType> { private AnyType[] stack = (AnyType[]) new Object[5]; ... } source - http://www.cs.cmu.edu/~adamchik/15-121/lectures/Collections/collections.html
Read more

OOPS: Decomposition and Abstraction

When we write a a program and if the the code is expected to be less than few hundred of lines then we can afford to write a monolithic program but if the number of lines increase it becomes difficult  to maintain that program or adding new features to that program.  so how to handle this ? In order to write a program for a problem , the problem should be broken into multiple smaller problems and then each smaller problem should be solved  and make sure that solving all such smaller problem solves the actual , bigger problem. the process of breaking a problem into multiple smaller problem efficiently involves Decomposition and Abstraction. Definitions Decomposition- How to decompose large programming problems into small ones is called decomposition Abstraction - Abstraction is a way to do decomposition productively by changing the level of detail to be considered. In each iteration the irrelevant information can be removed. The process of abstraction can be seen as an app...
Read more