The Java Blog

Interesting article on Reloading Java Classes

2011-01-18T03:23:00.000-08:00

Look at the code below. TAll the code is trying to achieve is get an instance of iExample. However, kind of complex code.

public class ExampleFactory {
public static IExample newInstance() {
URLClassLoader tmp =
new URLClassLoader(new URL[] {getClassPath()}) {
public Class loadClass(String name) {
if ('example.Example'.equals(name))
return findClass(name);
return super.loadClass(name);
}
};

return (IExample)
tmp.loadClass('example.Example').newInstance();
}
}"

JDK 7: Support for dynamically-typed languages

2011-01-17T08:04:00.000-08:00

JDK 7 is getting ready for GA. One of the very interesting feature of JDK 7 is invoke_dynamic which is about support for dynamically typed language at performance levels near to that of Java language. So far, following has been supported:

invoke_virtual :Interface related methods

invoke_special: private methods invocation

invoke_static: Static method invocation

Other enhancements are following:

Language enhancements such as following:

- Support for String in Switch-case

- Simplified varargs

- automatic resource management

- Multi-catch statement as part of improved exception handling

Upgraded class loader architecture to avoid deadlocks in case of non-hierarchy topologies

Method to close URLClassLoader

Enhanced Concurrency framework

-- A lightweight fork/join framework, flexible and reusable synchronization barriers, transfer queues, a concurrent-reference HashMap, and thread-local pseudo-random number generators

Internationalization related enhancements

I/O and networking related enhancements

JDBC

Security & Cryptography

JDK 7 Features: "Support for dynamically-typed languages"

Is this beginning for end of Java?

2011-01-16T18:47:00.000-08:00

Not sure. But with following, I am thinking if developers should start learning newer JVM languages such as Groovy, Scala, JRuby.

1. Apache Software Foundation (ASF) resigned from Java community.

2. Google & Oracle battling over Java technology

3. Would Java remain open source after Oracle mis-adventures

Software development predictions for 2011 - JavaWorld

JMSAppenders COnfiguration for Various Servers

2011-01-14T13:13:00.000-08:00

JBoss Server:

Properties env = new Properties( ); env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory"); env.put(Context.PROVIDER_URL, "jnp://hostname:1099"); env.put(Context.URL_PKG_PREFIXES, "org.jboss.naming:org.jnp.interfaces"); InitialContext jndiContext = new InitialContext(env);

WebLogic Server:

Properties env = new Properties( ); env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory"); env.put(Context.PROVIDER_URL, "t3://localhost:7001"); InitialContext jndiContext = new InitialContext(env);

Log4J Appenders Performance Analysis

2011-01-14T12:51:00.000-08:00

This page would give a fair idea of how various log4j appenders perform at a very high load. Well, these are not my stress lab readings, and need to be tested. However, this should give a fair idea for understanding various appenders performance.

http://www.ingrid.org/jajakarta/log4j/jakarta-log4j-1.1.3/docs/api/org/apache/log4j/performance/Logging.html

Also, question is whethar to use JMSAppender alone or use AsyncAppender and JMSAppender. The analysis of these are given in following page:

http://www.theserverside.com/discussions/thread.tss?thread_id=18742

I have tried following scenario and TPS (transaction per second) came almost same in both the case in case of load of 100 threads in 60 sec.

AsyncAppender sending messages to Console and File Appender

And

Messages are sent directly to Console and File Appender

I need to do further analysis to come out with right set of observation.

JVM Language - Groovy, JRuby, Scala and Java

2011-01-14T10:30:00.000-08:00

Well, this is definitely a news to me. I was looking at this webinar posted at InfoQ and all of a sudden realized that people have been really doing some good work in these other JVM languages such as groovy, Scala and Jruby.

Need to catch up on this... check out the seminar anyways..

http://www.infoq.com/interviews/venkat-subramaniam-jvm-languages

Flyweight Design Pattern

2006-12-19T23:57:00.000-08:00

I was wondering about Flyweight pattern for so many days. Let me present its definition and some detail.

Flyweight pattern: Flyweight is one of the structural patterns. The Flyweight Design Pattern is useful when there is the need for many, many objects to exist that share some information. Several thousand or even several hundred thousand objects might be needed, and this is usually very memory-consuming to keep track of. Given certain constraints, it is possible to reduce this problem greatly and make the presence of so many objects possible. If all of the objects share some intrinsic, invariant information that is constant among all of them, it can be removed from each object, and referenced. This eliminates the redundancy of having to repeat the same invariant, intrinsic information for each object, so instead of storing the same information n times for n objects, it is only stored once. This object that contains all of the intrinsic information is called a flyweight object.
It is possible for a flyweight to have extrinsic information as well. This information must be stateless and determined by context, having no stored values, but values that can be calculated on the spot.
The different components involved in the Flyweight Pattern are the Flyweight, the ConcreteFlyweight, the FlyweightFactory and the Client.

One classic example of a flyweight pattern is the characters stored in a word processor. Each character represents an object that has a font face, font size, and other formatting data. As you can imagine, a large document with this data structure would bloat the memory footprint of the word processor. Moreover, since much of this data is repeated, there must be a way to reduce the footprint - the Flyweight pattern. Each of the character objects would contain a reference to a separate formatting object which contains the required properties. This greatly reduces the memory footprint by combining all of the like-formatted characters into simpler objects that reference a single formatting object.

In Design Patterns, the Gang of Four (GOF) authors describe the Flyweight pattern like this:

Use sharing to support large numbers of fine-grained objects efficiently.

Memory Leak

2006-12-19T23:51:00.000-08:00

Memory Leak: Unintentional object retention is sometimes called as "memory leaks". It could come about in several ways. One of the case is when an object is no longer needed is referenced through some path from the rootset.

OOP vs AOP

2006-12-18T21:18:00.000-08:00

OOP is object-oriented programming that modularizes software using basic oop concepts such as encapsulation, inheritance and polymorphism. OOP is not bound to any programming languages.

AOP is aspect-oriented programming. AOP modularizes software applications based on loosely coupled aspects. AOP is a concept and not bound to any programming language. Software vendors can provide implementation for AOP in any programming language and make it available for the entire software community. For example, AspectJ (http://www.aspectj.org/ ).
A concern is nothing but a function in a given system. Any system is typically composed of both core and non-core concerns. The non-core concerns such as logging and security are actually the supporting functionalities for the mainstay core functionalities. The core functionality is the one that the system is expected to do.
AOP helps separate the non-core concerns from the core concerns by implementing concerns as aspects. Each aspect is independent and loosely coupled with other aspects in the system. This provides the flexibility for developers to enhance or remove any aspect at a later point in time without affecting the design and current state of the system.

Examples of AOP are following:

1. Logging functionality which is non-core concern could be implemented as one of the aspect.
2. Benchmarking logic such as time stamps across a block of code could be senn as one of the aspect.

Using AOP prevents the utility codes to be tightly coupled from the main code.

For detail, go to http://www.developer.com/lang/article.php/3649681

Visitor Pattern : Java

2006-12-14T02:12:00.000-08:00

I was trying to understand Visitor design pattern when I got into Single-dispatch and double-dispatch terms. Well, understanding of visitor pattern is enhanced once you understand the dispatch terminology in OOPs.

Single dispatch is a mechanism where a function call on an object is rightly dispatched to correct method based on the type of the object. The arguments of function call do not really matters. However, in a double dispatch mechnism, a function call is dispatched to different concrete functions depending on the runtime types of multiple objects involved in the call. Java does support single dispatch mechsnism. However, there is MultiJava compiler written to take of double dispatch mechanism. Check out a nice simple reading on dispatch definition, http://ifacethoughts.net/2006/07/29/single-double-and-multiple-dispatch/

The link http://rileywhite.com/software/visitorpattern.html presents nice explanation on the visitor pattern. One thing is sure. Visitor pattern is definitely hard to learn, unlike adapter, observer, factory patterns which are intuitive and widely used.

Another great reading on visitor pattern, which I really loved, is http://www.javaworld.com/javaworld/javatips/jw-javatip98.html .

Definition: The Visitor pattern lets us define a new operation on an object structure without changing the classes of the objects on which it operates. Rather than writing dedicated methods for each programming task and afterwards recompiling, the idea is to (1) insert a so-called accept method in each class, and (2) write the action code in so-called visitors.

One example code for visitor pattern is http://bobcat.webappcabaret.net/javachina/jc/ptn/Visitor.htm

Java Concurrency

2006-12-13T21:50:00.000-08:00

Concurrency according to http://dictionary.reference.com/browse/Concurrency is following:

1. Simultaneous occurrence; coincidence: the concurrence of several unusual events. OR,
2. Acting together as of agents or circumstances or events

Example of concurrent application could be following:

1. The streaming audio application must simultaneously read the digital audio off the network, decompress it, manage playback, and update its display.
2. The word processor should always be ready to respond to keyboard and mouse events, no matter how busy it is reformatting text or updating the display.

The Java platform is designed from the ground up to support concurrent programming, with basic concurrency support in the Java programming language and the Java class libraries. Since version 5.0, the Java platform has also included high-level concurrency APIs. This lesson introduces the platform's basic concurrency support and summarizes some of the high-level APIs in the java.util.concurrent packages. They are following:
    *  Lock objects support locking idioms that simplify many concurrent applications.
    * Executors define a high-level API for launching and managing threads. Executor implementations provided by java.util.concurrent provide thread pool management suitable for large-scale applications.
    * Concurrent collections make it easier to manage large collections of data, and can greatly reduce the need for synchronization.
    * Atomic variables have features that minimize synchronization and help avoid memory consistency errors.

For detail, visit http://java.sun.com/docs/books/tutorial/essential/concurrency/highlevel.html.

Going a little bit over basics, in concurrent programming, there are two basic units of execution: processes and threads. In the Java programming language, concurrent programming is mostly concerned with threads. However, processes are also important.

Processes

A process has a self-contained execution environment. A process generally has a complete, private set of basic run-time resources; in particular, each process has its own memory space.

Processes are often seen as synonymous with programs or applications. However, what the user sees as a single application may in fact be a set of cooperating processes.

Most implementations of the Java virtual machine run as a single process. A Java application can create additional processes using a ProcessBuilder object.

Threads

Threads are sometimes called lightweight processes. Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process.

Threads exist within a process - every process has at least one. Threads share the process's resources, including memory and open files. This makes for efficient, but potentially problematic, communication.

Multithreaded execution is an essential feature of the Java platform.from the application programmer's point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads.

Java Multi-threading Vs Dual Core Processor

2006-12-13T21:15:00.000-08:00

Multithreading could be categorized in two kinds:

1. Temporal multithreading where operating systems simulate doing many things at once by rapidly time-slicing between threads.
2. Simultaneous multithreading (SMT) when multiple threads executes instructions during the same clock cycle.

The java multithreading which we have known so far is actually temporal multithreading as most processors so far has been capable of executing only a single thread in a given time-slice.

True concurrency could actually be termed as Simultaneous multithreading (SMT). In past, SMT has been possible only on high-end multiprocessor systems. There arrives the Intel Dual Core Processor.

Intel dual core processor consists of two complete execution cores in one physical processor, both running at the same frequency. This is intended to provide immediate advantages to people looking to buy systems that boosts multitasking computing power and improve the throughput of multithreaded applications. To read more about dual core processors, refer http://www.intel.com/technology/computing/dual-core/.

Running Java program on a dual core processor does not immediately inherit advantages provided by SMT. One has to adapt the algorithms such that time consuming sections are performed by multiple threads designed to run simultaneously.

The java concurrency API should be used in such cases to speed up time-consuming tasks on dual core processors. The package java.util.concurrent classes could be used to achieve true concurrency. A simple approach for multithreading follows:
1. Develop a single-threaded, sequential, robust, and clearly organized version of your algorithm.
2. Identify the subtasks.
3. Benchmark the algorithm.
4. Delegate the most time-consuming subtasks to a thread pool.

For detail reading on java hyper-threading, visit http://www.javaworld.com/javaworld/jw-11-2006/jw-1121-thread.html?fsrc=rss-index

Java SE 6 Support for Javascript

2006-12-12T19:25:00.000-08:00

Talking about javascript, Java SE 6 has support for javascripting. Earlier to this release, I found myself using mozilla rhino.jar file. Now that’s cool new feature of Java SE 6. For those who want to quickly get familiar with javascript, try out the website, http://www.quirksmode.org/js/contents.html.
Cheers.

JVM and Three kinds of memory

2006-12-11T21:11:00.000-08:00

JVM has following three kinds of memory:

1. Heap memory: Runtime data area from which memory for all class instances and array is allocated.
2. Non-heap memory: Method area and memory required for internal processing. Method area stores code for method and constructors. It stores per class structures such as runtime constant pool, field and method data.
3. Native memory: Virtual memory managed by the operating system.

Java Application Common Problems

2006-12-11T21:03:00.000-08:00

My Java application was running fine some time before and now in the later release, it is slow or it is acting unresponsive. At times, it hangs too.
Well, some of the problems with java application could be following:

1. Insufficient memory. The symptom is when one gets OutOfMemoryError.
2. Memory Leaks: Following could be symptoms:
    - Growing use of memory
    - A class with high growth rate
    - A class with an unexpected number of instances
    - An object being referenced unintentionally
3. Finalizers: Objects are pending for finalization
4. Deadlocks: Thread blocks on object monitor or java.util.concurrent locks
5. Looping threads: Threads CPU time is continuously increasing
6. High lock contention: Thread with high contention statistics

Downcasting vs Upcasting in Java

2006-12-07T03:04:00.000-08:00

CharSequence l_sq0 = new String( "HelloWorld 0" );
System.out.println( "CharSequence: " + l_sq0.toString() );
// Downcasting CharSequence to String

String l_tstr2 = (String)l_sq0;
byte[] l_bytes = l_tstr2.getBytes();
System.out.println( "String: " + l_tstr2.toString() +
" Length: " + l_bytes.length );

String l_tstr = new String( "Hello World 1" );

// Upcasting String to CharSequence
CharSequence l_sq = (CharSequence)l_tstr;

System.out.println( "String: " + l_tstr.toString() );
System.out.println( "CharSequence: " + l_sq.toString() );

In the above example, String which implemented CharSquence in java.lang has been upcasted and downcasted at two different places. So, that is allowed.

Need a quick answer? Get one in minutes from people who know. Ask your question on Yahoo! Answers.

Does Programming Language really matter?

2006-12-07T02:06:00.000-08:00

I do not think programming languages really makes difference if the technology remain focussed on object-orientation. Based on one's project's requirements, one could choose the appropriate programming language and work accordingly.

Some of the famous ones are following:

Java

C++

Ruby (Recently)

Server-side Scriptling languages also support object-orientation. They are languages such as ASP, PHP.

Everyone is raving about the all-new Yahoo! Mail beta.

I am fed up with AJAX.

2006-12-05T00:23:00.000-08:00

Is AJAX worth that attention?

Give me a break! It is OK that AJAX is a cool technology, a Web 2.0 enabler. But, it has been there since so long. It is only that now, IT gurus have formalized the technology and guys out there are coming otu with so many toolkits. Do not why?

Well, its just that I goto http://java.sun.com to read every day and find that every 15 days there is one AJAX related article on the front home page.

Now, please give AJAX a break and move on.

Cheap Talk? Check out Yahoo! Messenger's low PC-to-Phone call rates.

Cool Features of Web Services in the Java SE 6 Platform

2006-11-30T02:49:00.000-08:00

I tried Java SE 6 webservices today by turning an existing class into webservice and it worked perfectly fine. I got it done both, manually and also using NetBeans 5.5. Watch out for annotation @WebService. If you selectively want to put methods as web services, you could as well use @WebMethod annotation. This is one cool feature thats coming in java se 6.

package generalproj;

import javax.jws.WebService;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import javax.xml.ws.Endpoint;

@WebService
public class GeneralClass {

    public GeneralClass() {
    }

    public void writeToFile( String a_file, String a_content ) {
        if( a_file != null && a_content != null ) {
            try {
                FileOutputStream l_fos = new FileOutputStream( new File( a_file ));
                byte[] l_bytes = a_content.getBytes();
                l_fos.write( l_bytes, 0, l_bytes.length );
                l_fos.close();
            } catch( IOException iox ) {
                iox.printStackTrace();
            }
        }
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Endpoint.publish(
         "http://localhost:8077/generalproj/GeneralClass",
         new GeneralClass());

}
}

For reference, visit the webpage http://java.sun.com/developer/technicalArticles/J2SE/jax_ws_2/

My java starters for the day!

2006-11-29T22:00:00.000-08:00

Some of the websites that I regulary visit these days are following:

http://www.developer.com/

http://www.infoq.com/

http://www-128.ibm.com/developerworks

http://java.sun.com/

http://www.theserverside.com/

My java readings for today!

2006-11-29T00:06:00.000-08:00

Some of the things I read today include following:

Always close IO streams.
Model Objects: Core problem domain objects.
IO buffering usually appropriate. Prefer IO buffering. Java IO classes for buffering are BufferedReader and BufferedWriter
Checked and unchecked exceptions: Checked exceptions are those which are, simply speaking, out of immediate control. For example, FileNotFoundException or network, database problem based exception. They need to be caught or passed to upward classes for compilation to happen successfully. Classes must oblige with checked exceptions. Unchecked exceptions are exceptions generated due to bad programming. Examples are ClassCastException, NullPointerException etc. Class need not to oblige with unchecked exceptions.

Interface or multiple inheritence?

2006-10-10T06:42:00.000-07:00

Well, I thought I could quickly put something about interfaces and their significance in java in particular and object oriented programming in general.

Let us take a look at the interface.


public interface IRole {
    String getName();
    
    String getDescription();
}

The above interface describes a contract that every class has to meet in order to be non-abstract. For example, say there are two different roles, one of student and other of teacher.

For above two roles, I would write two implementations. They are StudentRoleImpl and TeacherRoleImpl.

Both of the below statements are valid:

IRole l_role = new StudentRoleImpl();

IRole l_role = new TeacherRoleImpl();

To continue further...!

Java String - What is there to discuss?

2006-10-02T08:12:00.000-07:00

Java String presents lots of confusion if you really do not understand the basics very tightly. Look at the following two statements:

Statement 1
String s1 = "hello world";

Statement 2
String s2 = new String( "hello world" );

Wha is the difference between the above two statements?

Statement 1 means: String variable s1 refers to a string "hello world" in the string pool maintained by JVM. Thus, JVM first searches for the string "hello world" in the string pool. If it finds one, it returns the reference to the string. If it does not find, it creates an entry "hello world" in the string pool.

Thus, next time, you create String s3 = "hello world", variable s3 points to alreasy existing "hello world" in the string pool.

Statement 2 means: A new object is created on the heap and the reference to it is passed to variable s2.

Enough of reading and experimenting! Lets start some posting!

2006-09-05T20:36:00.000-07:00

O yes, I have doing a lot of reading and experimenting with various newer technologies. I thought to test my tech writing skills. So here I am!

Well, I would not be sticking to any technologies. But, I must admit that I love OOAD and I love any language which strengthen OOAD.