Win a copy of Java Database Connections & Transactions (e-book only) this week in the JDBC forum!
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other all forums
this forum made possible by our volunteer staff, including ...
  • Campbell Ritchie
  • Devaka Cooray
  • Knute Snortum
  • Paul Clapham
  • Tim Cooke
  • Liutauras Vilda
  • Jeanne Boyarsky
  • Bear Bibeault
Saloon Keepers:
  • Tim Moores
  • Stephan van Hulst
  • Ron McLeod
  • Piet Souris
  • Frits Walraven
  • Ganesh Patekar
  • Tim Holloway
  • salvin francis

classloader  RSS feed

Posts: 23
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator

whatz actually happening when we run a class;i knew that main method is the entry point for execution and classloader is responsible for loading the class when it sees some line like new myclass();but my question is even to get to the main method the class has to be already loaded;

Posts: 23832
C++ Chrome Eclipse IDE Firefox Browser Java jQuery Linux VI Editor Windows
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
The main() method is the "entry point for execution" for your java program. The starting point for the JVM is something else. This starting point call code that parses the parameters, setups tons of internal stuff, loads and configure the class loader, load your class specified in the parameters (with the class loader), and then call your main() method.

author and cow tipper
Posts: 5000
Hibernate Spring Tomcat Server
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
Heh...Who cops the cops is what you're asking...Who loads the first classloader?

I wrote a number of articles on classloaders. Here's a segment of one of them on the null classloader. I hope you enjoy. You can read the rest of the arcticle here if you please. It's a little WebSphere specific:

Everything You Want to Know About WebSphere and J2EE Classloaders

Java classes are loaded by classloaders, and classloaders are Java components, who loads the first classloader?

The old chicken and egg scenario, rearing its ugly head. If classloaders are Java classes, and Java classes must be loaded onto a JVM to run, how does the first classloader get loaded? It�s a good question.

When a JVM starts up, a special chunk of machine code runs that loads the system classloader. This special hunk of machine code is known as the null classloader.

The Null Classloader

The machine code that initializes the system classloader is referred to as the null classloader because it is not a Java class at all, as are all other classloaders. The null classloader is platform specific machine instructions that kick off the whole classloading process.

All classloaders, with the exception of the null classloader, are implemented as Java classes. Something must load the very first Java classloader to get the process started. Loading the first pure Java classloader is the job of the null classloader.

The null classloader also takes care of loading all of the code needed to support the basic Java Runtime Environment (JRE), including classes in the java.util and the java.lang packages.
The System Classloader: sun.misc.Launcher

The null classloader loads a true Java class of type sun.misc.Launcher. The sun.misc.Launcher classloader prepares the basic Java Runtime Environment needed by our application server.

Truth be told, the sun.misc.Launcher is actually made up of two inner classes that do the actual classloading:

F sun.misc.Launcher$ExtClassLoader (parent)
F sun.misc.Launcher$AppClassLoader (system)

ExtClassLoader is the parent of AppClassLoader. Of the two, the inner class, sun.misc.Launcher$AppClasLoader holds the true title of system classloader

Quite appropriately, the sun.misc.Launcher is often referred to as the bootstrap classloader as well as the system classloader. Any jars found in the jre/lib directory of the JRE (not the WebSphere lib directory), will be loaded by the system classloader. The system classloader is tightly integrated with the components that implement the Java Runtime Environment (JRE).

From within the WebSphere administrative console, you have the option of adding Java files and resources to the WebSphere CLASSPATH. When you add libraries to the WebSphere CLASSPATH, you are actually asking the system classloader to load those classes when they are needed. Appropriately, the system classloader is also known as the CLASSPATH classloader.
sri jaisi
Posts: 23
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
thankz henry and thankz kameron

kameron i read your article and i still got some doubts and please can you explain them in little more detail
let me start again with a simple example:
java;now null classloader instantiates system classloader (as classloaders are hierarchial and as they follow delegation module extension loader ,bootstrap loader will try to load myclass.class file when it come across the line new myclass());
am i correct here?(or else bootstrap loader loads java.* classes and extension loader loads javax.*,and system class loader is the one responsible to load user defined classes in my case i.e.myclass.class)

2.if iam having one public class and two are more non public classes within the same file and if iam instantiating them means eg;new a();new b();new c();then wil three insances of system class loader will be created and each instance will try to find the corresponding .class file;
am i correct here

thankz for reading
author and iconoclast
Posts: 24203
Chrome Eclipse IDE Mac OS X
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
Note that much of what K/Cameron is saying is implementation-dependent and undocumented -- not stuff you need to know. The important points are that the JVM itself starts up, and a specific class loader is created for the purpose of loading application classes. The Java application launcher (i.e., java.exe) then uses this class loader, along with the class name you specify on the command line and the Class.forName() function, to load the class in which main() is expected to appear. main() is then invoked using reflection (or equivalent magic.)

There's just a single application class loader; Java won't create any more class loaders once it starts loading your application classes.
That new kid is a freak. Show him this tiny ad:
how do I do my own kindle-like thing - without amazon
  • Post Reply Bookmark Topic Watch Topic
  • New Topic
Boost this thread!