Posts by Chang Park

Phantom Reference in Soot

Phantom

Definition

Phantom classes are classes that are neither in the process directory nor on the Soot classpath, but that are referenced by some class / method body that Soot loads.

  • Process Directory: contains Application classes.
  • Soot Classpath: contains Library Classes.

There are several scenarios that reference classes don’t exist. A developer might leave the code to improve it later, or he got rid of some jar files that was in use but not executable. Sometimes people left such code because it will not be reachable on runtime anyway.

However there is another case that is significant. The actual reference classes can be inside of the actual device, and can be not showing until it runs. So in this case, it will be bad idea to touch or to handle this phantom classes.

 

–allow-phantom-refs

  • Soot option that can handle phantom classes. (not recommended by Soot)
  • Only use this option if you know what you are doing.
  • Soot will not just abort and fail on such an unresolvable reference, but create an empty stub called a phantom class which in turn contains phanom methods to make up for the missing bits and pieces.

 

Garbage Collection

GCDuke

How Garbage Collection Really works

All objects are allocated on the heap area managed by the JVM. Every item that the developer uses is treated this way, including class objects, static variables, and even the code itself. As long as an object is being referenced, the JVM considers it alive. Once an object is no longer referenced and therefore is not reachable by the application code, the garbage collector removes it and reclaims the unused memory.

allocation

Garbage Collector root

  • Local variables in the main method
  • The main thread
  • Static variables of the main class

gc-roots

Mark and Sweep Algorithm

  • The algorithm traverses all object references, starting with the GC roots, and marks every object found as alive.
  • All of the heap memory that is not occupied by marked objects is reclaimed. It is simply marked as free, essentially swept free of unused objects.
  • When objects are no longer referenced directly or indirectly by a GC root, they will be removed. There are no classic memory leaks.

 

 

Java Memory Structure

types of memory area

memory21

Static memory (Method area)

  • Method information and Field information.
  • Global constants and other data generated by the compiler(e.g. info to support garbage collection) are allocated static storage.
  • Static variables are bound to memory cells before execution begins and remains bound to the same memory cell throughout execution. E.g., static variables.

Stack

  • Names local to a procedure and Parameters are allocated space on a stack. The size of stack can not be determined at compile time.

Heap

  • Data that may outlive the call to the procedure that created it is usually allocated on a heap. E.g. new to create objects that may be passed from procedure to procedure.
  • The size of heap can not be determined at compile time. Referenced only through pointers or references, e.g., dynamic objects in C++, all objects in Java
  • Garbage collection cleans up data(not using) on heap.

 

Example

class Point {
   int x, y;

   void move(int x, int y) {
      this.x = x;
      this.y = y;
   }

   int getX() {
      return x;
   }

   int getY() {
      return y;
   }

   void setX(int x) {
      this.x = x;
   }

   void setY(int y) {
      this.y = y;
   }

   void draw() {
      System.out.println("Point(" + x + ", " + y + ")");
   }
}

class PointTest {
   public static void main(String args[]) {
      Point p1, p2 = null;

      p1 = new Point();
      p1.move(4, 4);
      // Point 1
      p2 = new Point();
      p2.move(2, 4);

      // Point 2
   }
}

[ PointTest class loaded ]

m1

 

[ JVM calls Main method ]

m2

 

[ At Point 1 in Main method ]

m3

 

 [ At Point 2 in Main method ]

m4

 

Java features

java_logo

Simple

  • Java is Easy to write and more readable and eye catching.
  • Java has a concise, cohesive set of features that makes it easy to learn and use.
  • Most of the concepts are drew from C++ this making Java learning simpler.

Secure

  • Java program cannot harm other system thus making it secure.
  • Java provides a secure means of creating Internet applications.
  • Java provides secure way to access web applications.

Portable

  • Java programs can execute in any environment for which there is a Java run-time-system.(JVM)
  • Java programs can be run on any platform (Linux, Window, Mac)
  • Java programs can be transferred over world wide web (e.g applets)

Object-oriented

  • Java programming is pure object-oriented programming language. (while C++ is semi object oriented)
  • Like C++, java provides most of the object oriented features.

Robust

  • Java encourages error-free programming by being strictly typed and performing run-time check.

Multithreaded

  • Java provides integrated support for multithreaded programming.

Architecture-neutral

  • Java is not tied to a specific machine or operating system architecture.
  • Machine independent i.e Java is independent of hardware.

Interpreted

  • Java supports cross-platform code through the use of Java bytecode.
  • Bytecode can be interpreted on any platform by JVM.

High Performance

  • Bytecodes are highly optimized.
  • JVM can be executed them much faster.

Distributed

  • Java was designed with the distributed environment.
  • Java can be transmit, run over internet.

Dynamic

  • Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve access to objects at run time.

 

[String] concat() vs. +

Screen Shot 2016-08-07 at 4.44.23 PM

concat() and + both add up strings. It looks same, but + do one more step. As seen below, + will create string builder and append the strings inside, and then it will give the string. So, concat() is less expensive.

/*      Using + sign      */
String myStr = "str";
myStr += "end";

// Same as above
String myStr = "str";
myStr = new StringBuilder().append(myStr).append("end").toString();

 

/*      Using concat()     */
String myStr = "str";
myStr = myStr.concat("end");

 

DHCP

Definition & steps

DHCP stands for Dynamic Host Configuration Protocol. When DHCP assigns an IP address, it actually leases that connection identifier to the user’s computer for a specific amount of time. The default lease is five days.

Pros

  • Because there is certain lease duration, if not using after the duration, they will automatically collect it after the lease. So, it can be used for other computer.
  • Because you don’t need to set the IP one by one, if you move to other office and connect to the that network, it will automatically assign an IP for you.

Screen Shot 2016-08-07 at 12.36.24 PM

How DHCP works

  • Discover: client computer sends a broadcast request looking for a DHCP server to answer.
  • Router directs the DISCOVER packet to the correct DHCP server.
  • The server receives the DISCOVER packet. Based on availability and usage policies set on the server, the server determines an appropriate address (if any) to give to the client.
  • Offer: The server then temporarily reserves that address for the client and sends back to the client an OFFER packet, with that address information.
  • Request: Letting the server know that it intends to use the address.
  • ACK: Confirming that the client has a been given a lease on the address for a server-specified period of time.

 

 

Error & Exception

Error & Exception

Screen Shot 2016-08-06 at 10.39.14 PM

Error is thrown by JVM in a scenario which is fatal and there is no way for the application program to recover from that error.

  • Unchecked type: Errors happen at run time. They will not be known to compiler
  • Cannot recover
  • eg. java.lang.StackOverflowError, java.lang.OutOfMemoryError

Exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

  • Unchecked & Checked type: checked exceptions are known to compiler where as unchecked exceptions are not known to compiler because they occur at run time.
  • Can recover from exceptions by handling then through try-catch blocks.

 

Types of exceptions

  • Checked Exception: The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions. Checked Exceptions are checked at compile-time.
    • e.g.IOException, SQLException etc.
  • Unchecked Exception: Unchecked exceptions are not checked at compile-time rather they are checked at runtime.
    • e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.

 

Unchecked Exception scenarios

  • ArithmeticException: If we divide any number by zero, there occurs an ArithmeticException.
int a = 50/0;

 

  • NullPointerException: If we have null value in any variable, performing any operation by the variable occurs an NullPointerException.
String s = null;
System.out.println(s.length());

 

  • NumberFormatException: The wrong formatting of any value, may occur NumberFormatException. Suppose I have a string variable that have characters, converting this variable into digit will occur NumberFormatException.
String s = "abc";
int i = Integer.parseInt(s);

 

  • ArrayIndexOutOfBoundsException: If you are inserting any value in the wrong index, it would result ArrayIndexOutOfBoundsException as shown below.

int a[] = new int[5];

a[10] = 50;

 

Handling checked exceptions

Due to compilation error, checked exceptions need to be handled by programmer. There are two ways to handle these exceptions.

  • Throw when declaring method
  • Try, catch, and finally inside the method

 

Throw when declaring method: Toss the exception handling to user when using the method.

public void connect() throws MyException{
   // try ~ catch ~ finally will not be used
}

 

Try, catch, and finally inside the method: Handling exception inside the method

public void connect(){

   try{
      // Do work here
      System.out.println(10/0);
   } catch (MyException e){
      // Catch lower Exception first
   } catch (Exception e){
      // Highest Exception at the end

      // There are three ways to see the excetption
      e.printStackTrace();
      System.out.println(e.toString());
      System.out.println(e.getMessage());
   } finally {
      // Code on here will be always printed
   }

}
  • e.printStackTrace(): Name of the Exception, Message of the Exception, Stack trace
    • On example code above:
java.lang.ArithmeticException: /by Zero
   at main()
  • e.toString(): Name of the Exception, Message of the Exception
    • On example code above:
java.lang.ArithmeticException: /by zero
  • e.getMessage(): Message of the Exception
    • On example code above:
/by zero

Creating your own Exception

Extends Exception classe: you can make the most suitable exception for your program.

public class MyException extends Exception{
   public Myexception(String msg){
      super(msg);
   }
}

 

 

 

Wait() vs. Sleep()

Wait and sleep method are completely different to each other

  • wait() & notify(): method for inter thread communication.
  • sleep(): introducing small pause during thread execution.

Screen Shot 2016-07-26 at 2.49.35 PM

wait() & notify()

  • wait() method puts a thread on wait
    • For example, in Producer Consumer problem, producer thread should wait if Queue is full or Consumer thread should wait if Queue is empty.
  • notify()  & notifyAll() method is used to wake up waiting thread by communicating that waiting condition is over now
    • For example, once producer thread puts an item on empty queue it can notify Consumer thread that Queue is not empty any more.
    • notify(): wakes up one thread
    • notifyAll(): wakes up all the threads (use this when you are not sure which one to use)
Example...
/*
   Until pizza arrives, eatPiazza will in wait
   If pizzaGuy() executed, it will wake up eatPiazza()
   by using notifyAll();
*/
class MyHouse{
   private boolean pizzaArrived = false;
   
   public void eatPizza(){
      synchronized(this){
         while(!pizzaArrived){
            wait();
         }
      }
      System.out.println("yumyum...");
   }

   public void pizzaGuy(){
      synchronized(this){
         this.pizzaArrived = true;
         notifyAll();
      }
   }
}

sleep()

  • sleep() hold a lock, doesn’t release any lock or monitor while sleeping.
  • When a Thread goes to Sleep it can be either wake up normally after sleep duration elapsed or it can be woken up abnormally by interrupting it.
Example...
/*
   It will print out count string one at a time
   with a 3 seconds term
*/
public class Example{
   public static void main(String[] args){
      String count[] = ("One","Two","Three","Four","Five");

      for(int i=0; i<count.length;i++){
         Thread.sleep(3000);             // sleep for 3 seconds
          System.out.println(count[i]);  // printout count string
      }
   }
}

Synchronized in Thread

synchronized

  • While running multi-threads, there will be a significant problem when those threads try to use same resource.
    • For example, multiple people try to deposit money into the same account. Let’s say initial balance is $0. If 5 people are accessing at the same time, they all will see $0 as an account balance. Then, after all people’s deposit of $500 each, it will have $500 for total deposit. This is because they accessed at the same time, and they all updated balance as $500. However, the balance should be $2,500.
  • So, lock is needed to avoid other thread trying to use the same resource at the same time.
  • That lock can be done by Synchronized.

There is two ways to use synchronized.

  • Synchronized method
public synchronized /* Method name  */(){
   ...
}
  • Synchronized block
synchronized( /* Object to be shared */ ){
   ...
}

Primitive type vs. Reference type

Primitive vs Reference Type Java

Primitive type

  • Basic types for characters, different kinds of integers, and different kinds of floating point numbers (numbers with a decimal point), and also types for the values true and false – char, int, float, and bool. All of these basic types are known as primitive types.
  • The value of the variable is stored in the memory location assigned to the variable. For example, if an integer variable is declared as “int a = 5″, then when we look at the memory location of “a”, there will be a “5” stored there just as expected.

Reference type

  • You might be confused by all the different terminology used. However, class types, object types, and reference types all mean the exact same thing.
  • A variable of a reference type only stores the memory address of where the object is located. For example, “SomeClass anObject”, then when we look at “anObject” in memory, it just stores an address of another place in memory where all the details of “anObject” reside. This memory address is called a reference to the object.