1.描述一下JVM加载class文件的原理机制?
2.试举例说明一个典型的垃圾回收算法？
3.请用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来.
4.请写一个java程序实现线程连接池功能？
5.给定一个C语言函数，要求实现在java类中进行调用。
答1：
1.Java中的所有类，必须被装载到jvm中才能运行，这个装载工作是由jvm中的类装载器完成的，类装载器所做的工作实质是把类文件从硬盘读取到内存中
2.java中的类大致分为三种：
1.系统类
2.扩展类
3.由程序员自定义的类
3.类装载方式，有两种
1.隐式装载， 程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中，
2.显式装载， 通过class.forname()等方法，显式加载需要的类
隐式加载与显式加载的区别？两者本质是一样?
4.类加载的动态性体现
一个应用程序总是由n多个类组成，Java程序启动时，并不是一次把所有的类全部加载后再运行，它总是先把保证程序运行的基础类一次性加载到jvm中，其它类等到jvm用到的时候再加载，这样的好处是节省了内存的开销，因为java最早就是为嵌入式系统而设计的，内存宝贵，这是一种可以理解的机制，而用到时再加载这也是java动态性的一种体现
5．java类装载器
Java中的类装载器实质上也是类，功能是把类载入jvm中，值得注意的是jvm的类装载器并不是一个，而是三个，层次结构如下：
Bootstrap Loader - 负责加载系统类
|
- - ExtClassLoader - 负责加载扩展类
|
- - AppClassLoader - 负责加载应用类
为什么要有三个类加载器，一方面是分工，各自负责各自的区块，另一方面为了实现委托模型，下面会谈到该模型
6. 类加载器之间是如何协调工作的
前面说了，java中有三个类加载器，问题就来了，碰到一个类需要加载时，它们之间是如何协调工作的，即java是如何区分一个类该由哪个类加载器来完成呢。
在这里java采用了委托模型机制，这个机制简单来讲，就是“类装载器有载入类的需求时，会先请示其Parent使用其搜索路径帮忙载入，如果Parent 找不到,那么才由自己依照自己的搜索路径搜索类”，注意喔，这句话具有递归性
下面举一个例子来说明，为了更好的理解，先弄清楚几行代码：
Public class Test{
Public static void main(String[] arg){
ClassLoader c = Test.class.getClassLoader(); //获取Test类的类加载器
System.out.println(c);
ClassLoader c1 = c.getParent(); //获取c这个类加载器的父类加载器
System.out.println(c1);
ClassLoader c2 = c1.getParent();//获取c1这个类加载器的父类加载器
System.out.println(c2);
}
}
运行结果：
。。。AppClassLoader。。。
。。。ExtClassLoader。。。
Null
注： 。。。表示省略了内容
可以看出Test是由AppClassLoader加载器加载的
AppClassLoader的Parent 加载器是 ExtClassLoader 但是ExtClassLoader的Parent为 null 是怎么回事呵，朋友们留意的话，前面有提到Bootstrap Loader是用C++语言写的，依java的观点来看，逻辑上并不存在Bootstrap Loader的类实体，所以在java程序代码里试图打印出其内容时，我们就会看到输出为null
类装载器ClassLoader（一个抽象类）描述一下JVM加载class文件的原理机制
类装载器就是寻找类或接口字节码文件进行解析并构造JVM内部对象表示的组件，在java中类装载器把一个类装入JVM，经过以下步骤：
1、装载：查找和导入Class文件
2、链接：其中解析步骤是可以选择的
（a）检查：检查载入的class文件数据的正确性
（b）准备：给类的静态变量分配存储空间
（c）解析：将符号引用转成直接引用
3、初始化：对静态变量，静态代码块执行初始化工作
类装载工作由ClassLoder和其子类负责。JVM在运行时会产生三个ClassLoader：根装载器，ExtClassLoader(扩展类装载器)和AppClassLoader，其中根装载器不是ClassLoader的子类，由C++编写，因此在java中看不到他，负责装载JRE的核心类库，如JRE目录下的rt.jar,charsets.jar等。ExtClassLoader是ClassLoder的子类，负责装载JRE扩展目录ext下的jar类包；AppClassLoader负责装载classpath路径下的类包，这三个类装载器存在父子层级关系，即根装载器是ExtClassLoader的父装载器，ExtClassLoader是AppClassLoader的父装载器。默认情况下使用AppClassLoader装载应用程序的类
Java装载类使用“全盘负责委托机制”。“全盘负责”是指当一个ClassLoder装载一个类时，除非显示的使用另外一个ClassLoder，该类所依赖及引用的类也由这个ClassLoder载入；“委托机制”是指先委托父类装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。这一点是从安全方面考虑的，试想如果一个人写了一个恶意的基础类（如java.lang.String）并加载到JVM将会引起严重的后果，但有了全盘负责制，java.lang.String永远是由根装载器来装载，避免以上情况发生
除了JVM默认的三个ClassLoder以外，第三方可以编写自己的类装载器，以实现一些特殊的需求。类文件被装载解析后，在JVM中都有一个对应的java.lang.Class对象，提供了类结构信息的描述。数组，枚举及基本数据类型，甚至void都拥有对应的Class对象。Class类没有public的构造方法，Class对象是在装载类时由JVM通过调用类装载器中的defineClass()方法自动构造的
ClassLoader重要方法：
（1）public Class<?> loadClass(String name)
throws ClassNotFoundException
name参数指定类装载器需要装载类的名字，必须使用全限定类名。该方法有一个重载方法loadClass(String name,Boolean resolve)，resolve参数告诉类装载器是否解析该类。在初始化类之前应考虑进行类解析的工作，但并不是所有类都需要解析，如果JVM只需要知道该类是否存在或找出该类的超类，那么就不需要进行解析
（2）
【注：以下内容大部分引用java深度历险】
弄明白了上面的示例，接下来直接进入类装载的委托模型实例，写两个文件，如下：
文件：Test1.java
Public class Test1{
Public static void main(String[] arg){
System.out.println(Test1.class.getClassLoader());
Test2 t2 = new Test2();
T2.print();
}
}
文件： Test2.java
Public class Test2{
Public void print(){
System.out.println(this.getClass().getClassLoader());
}
}
这两个类的作用就是打印出载入它们的类装载器是谁， 将这两个文件保存到d:\TestClassLoder目录下，编译后，我们在复制两份，分别置于 <JRE所在目录>\classes下（没有此目录，需自己建立） 与 <JRE所在目录>\lib\ext\classes下（没此目录，手工建立）, 然后切换到D:\TestClassLoder目录下开始测试（查看当前用的jdk版本号，我用的jre所在目录为是C:\Program Files\Java\jdk1.6.0\jre）
测试一：
<JRE所在目录>\classes下
Test1.class
Test2.class
<JRE所在目录>\lib\ext\classes下
Test1.class
Test2.class
D:\TestClassLoder下
Test1.class
Test2.class
dos下输入运行命令，结果如下：
D:\TestClassLoder>java Test1
Null
Null
D:\TestClassLoder>
从输出结果我们可以看出，当AppClassLoader要载入Test1.class时，先请其Parent，也就是ExtClassLoader来载入，而ExtclassLoader又请求其Parent，即Bootstrap Loader来载入Test1.class. 由于 <JRE所在目录>\Classes目录为Bootstrap Loader的搜索路径之一，所以Bootstrap Loader找到了Test1.class,因此将它载入，接着在Test1.class之内有载入Test2.class的需求，由于 Test1.class是由Bootstrap Loader所载入，所以Test2.class内定是由Bootstrap Loader根据其搜索路径来找，因Test2.class也位于Bootstrap Loader可以找到的路径下，所以也被载入了，最后我们看到Test1.class与Test2.class都是由Bootstrap Loader（null）载入。
若<JRE所在目录>\lib\ext\classes下没有这两个类文件，结果也一样都为null
测试二：
<JRE所在目录>\classes下
Test1.class
<JRE所在目录>\lib\ext\classes下
Test1.class
Test2.class
D:\TestClassLoder下
Test1.class
Test2.class
dos下输入运行命令，结果如下：
D:\TestClassLoder>java Test1
Null
Exception in thread “main” java.lang.NoClassdefFoundError:Test2 at Test1.main。。。
D:\TestClassLoder>
从输出结果我们可以看出，当AppClassLoader要载入Test1.class时，先请其Parent，也就是ExtClassLoader来载入，而ExtclassLoader又请求其Parent，即Bootstrap Loader来载入Test1.class. 由于 <JRE所在目录>\Classes目录为Bootstrap Loader的搜索路径之一，所以Bootstrap Loader找到了Test1.class,因此将它载入，接着在Test1.class之内有载入Test2.class的需求，由于 Test1.class是由Bootstrap Loader所载入，所以Test2.class内定是由Bootstrap Loader根据其搜索路径来找，但是因为Bootstrap Loader根本找不到Test2.class（被我们删除了），而Bootstrap Loader又没有Parent，所以无法载入Test2.class.最后我们看到Test1.class是由Bootstrap Loader（null）载入，而Test2.class则无法载入
若<JRE所在目录>\lib\ext\classes下没有这两个类文件，结果也一样
测试三
<JRE所在目录>\classes下
Test2.class
<JRE所在目录>\lib\ext\classes下
Test1.class
Test2.class
D:\TestClassLoder下
Test1.class
Test2.class
dos下输入运行命令，结果如下：
D:\TestClassLoder>java Test1
。。。ExtClassLoader。。。
Null
D:\TestClassLoder>
从输出结果我们可以看出，当AppClassLoader要载入Test1.class时，先请其Parent，也就是ExtClassLoader来载入，而ExtclassLoader又请求其Parent，即Bootstrap Loader来载入Test1.class.但是Bootstrap Loader无法在其搜索路径下找到Test1.class(被我们删掉了)，所以ExtClassLoader只得自己搜索，因此 ExtClassLoader在其搜索路径 <JRE所在目录>\lib\ext\classes下找到了Test1.class，因此将它载入，接着在Test1.class之内有载入Test2.class的需求，由于Test1.class是由ExtClassLoader所载入，所以Test2.class内定是由 ExtClassLoader根据其搜索路径来找，但是因为ExtClassLoader有Parent,所以先由Bootstrap Loader帮忙寻找，Test2.class位于Bootstrap Loader可以找到的路径下，所以被Bootstrap Loader载入了.最后我们看到Test1.class是由ExtClassLoader载入，而Test2.class则是由Bootstrap Loader（null）载入
了解了以上规则，请朋友们自行分析以下场景的执行结果
测试四：
<JRE所在目录>\classes下
<JRE所在目录>\lib\ext\classes下
Test1.class
Test2.class
D:\TestClassLoder下
Test1.class
Test2.class
测试五：
<JRE所在目录>\classes下
<JRE所在目录>\lib\ext\classes下
Test1.class
D:\TestClassLoder下
Test1.class
Test2.class
测试六：
<JRE所在目录>\classes下
<JRE所在目录>\lib\ext\classes下
Test2.class
D:\TestClassLoder下
Test1.class
Test2.class
测试七：
<JRE所在目录>\classes下
<JRE所在目录>\lib\ext\classes下
D:\TestClassLoder下
Test1.class
Test2.class
答案：
测试四：
。。。ExtClassLoader。。。
。。。ExtClassLoader。。。
测试五：
。。。ExtClassLoader。。。
Exception in thread "main" java.lang.NoClassDefFoundError: Test2
at Test1.main。。。
测试六：
。。。ExtClassLoader。。。
。。。AppClassLoader。。。
测试七：
。。。AppClassLoader。。。
。。。AppClassLoader。。。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/alex197963/archive/2009/08/07/4417069.aspx
问题2：请用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来
private myTree tree;
/**
*二叉树的插入，参数为（关键字，数据）
*
**/
public void insert(int key, int data) {
if (tree == null) {
tree = new myTree();
tree.key = key;
tree.data = data;
} else {
myTree newTree = new myTree();
newTree.key = key;
newTree.data = data;
myTree parent = tree;
while (true) {
if (newTree.key < parent.key) {
if (parent.leftChild == null) {
parent.leftChild = newTree;
return;
} else {
parent = parent.leftChild;
}
} else if (newTree.key > parent.key) {
if (parent.rightChild == null){ parent.rightChild = newTree;
return;
} else {
parent = parent.rightChild;
}
}
}
}
}
/**
* 二叉树的查找，参数为（关键字），返回值为 myTree的一个实例
*
* **/
public myTree find(int key) {
if (tree == null)
return null;
myTree curr = new myTree();
curr.key = key;
myTree parent = tree;
while (true) {
if (parent == null) {
return null;
} else if (curr.key == parent.key) {
return parent;
} else if (curr.key > parent.key) {
parent = parent.rightChild;
} else if (curr.key < parent.key) {
parent = parent.leftChild;
}
}
}
/*
*
* 递归的二叉树中序遍历
*
*
*/
private static void midOrder(myTree tree) {
if (tree != null) {
midOrder(tree.leftChild);
System.out.println(tree + "," + tree.key + "," + tree.data);
midOrder(tree.rightChild);
}
}
/*
* 前序遍历
*/
private static void frontOrder(myTree tree) {
if (tree != null) {
System.out.println("" + tree.key + " , " + tree.data);
frontOrder(tree.leftChild);
frontOrder(tree.rightChild);
}
}
public static void main(String[] args) {
System.out.println("Tree view Begin");
MyTest t1 = new MyTest();
t1.insert(8, 25);
t1.insert(5, 9);
t1.insert(58, 87);
t1.insert(13, 82);
t1.insert(4,
;
t1.insert(12, 54);
t1.insert(53, 123);
t1.insert(56, 47);
t1.insert(2, 75);
t1.insert(34, 5);
t1.insert(6, 23);
System.out.println("现在开始遍历:");
frontOrder(t1.tree);
midOrder(t1.tree);
}
}
class myTree {
int key;
int data;
myTree leftChild;
myTree rightChild;
}
转 http://www.itzhuyi.com/item/Print.asp?ID=10266&m=1
public abstract class Manager {
private String mThreadPoolName = null;
private int mThreadPoolMaxSize = 1;
private LinkedList workers = new LinkedList();
public Manager() {
}
public Manager(String name, int poolMaxSize) {
mThreadPoolName = name;
createWorker(name, poolMaxSize);
mThreadPoolMaxSize = poolMaxSize;
}
private void createWorker(int poolMaxSize) {
for (int i = 0; i < poolMaxSize; i++) {
Worker worker = new ...Worker(this);
workers.addLast(worker);
}
}
public synchronized Worker getIdleWorker() {
return (Worker)workers.removeFirst();
}
public synchronized void notifyFree(Worker worker) {
if (workers.size() < mThreadPoolMaxSize) {
workers.addLast(worker);
} else {
worker = null;
}
}
public int getThreadPoolMaxSize() {
return mThreadPoolMaxSize;
}
public void setThreadPoolMaxSize(int threadPoolMaxSize) {
this.mThreadPoolMaxSize = threadPoolMaxSize;
}
}
线程抽象类
public abstract class Worker implements Runnable {
private Manager mManager = null;
private Thread mThread = null;
public Worker() {
}
public Worker(String threadName, Manager manager) {
mManager = manager;
mThread = new Thread(this, threadName);
init();
mThread.start();
}
public abstract void init();
public void run() {
while (true) {
waitForStart();
Worker worker = mManager.getIdleWorker();
process();
isRunning = false;
mManager.notifyFree(worker);
}
}
public abstract void process();
public void start() {
isRunning = true;
mManager.getIdleWorker();
notifyToStart();
}
public synchronized void waitForStart() {
try {
wait();
} catch (InterruptedException ex) {
}
}
public synchronized void notifyToStart() {
notify();
}
}
转 http://www.itzhuyi.com/Item/Show.asp?d=10268&m=1
线程是Java的一大特性，它可以是给定的指令序列、给定的方法中定义的变量或者一些共享数据(类一级的变量)。在Java中每个线程有自己的堆栈和程序计数器（PC），其中堆栈是用来跟踪线程的上下文（上下文是当线程执行到某处时，当前的局部变量的值），而程序计数器则用来跟踪当前线程正在执行的指令。
通常情况，一个线程不能访问另外一个线程的堆栈变量，而且这个线程必须处于如下状态之一：
1.排队状态（Ready），在用户创建了一个线程以后，这个线程不会立即运行。当线程中的方法start()被调用时，这个线程就会进行排队状态，等待调度程序将它转入运行状态（Running）。当一个进程被执行后它也可以进行排队状态。如果调度程序允许的话，通过调用方法yield()就可以将进程放入排队状态。
2.运行状态(Running)，当调度程序将CPU的运行时间分配给一个线程，这个线程就进入了运行状态开始运行。
3.等待状态（Waiting），很多原因都可以导致线程处于等待状态，例如线程执行过程中被暂停，或者是等待I/O请求的完成而进入等待状态。
在Java中不同的线程具有不同的优先级，高优先级的线程可以安排在低优先级线程之前完成。如果多个线程具有相同的优先级，Java会在不同的线程之间切换运行。一个应用程序可以通过使用线程中的方法setPriority()来设置线程的优先级，使用方法getPriority()来获得一个线程的优先级。
线程的生命周期
一个线程的的生命周期可以分成两阶段：生存（Alive）周期和死亡（Dead）周期，其中生存周期又包括运行状态（Running）和等待状态（Waiting）。当创建一个新线程后，这个线程就进入了排队状态（Ready），当线程中的方法start()被调用时，线程就进入生存周期，这时它的方法isAlive()始终返回真值，直至线程进入死亡状态。
线程的实现
有两种方法可以实现线程，一种是扩展java.lang.Thread类，另一种是通过java.lang.Runnable接口。
Thread类封装了线程的行为。要创建一个线程，必须创建一个从Thread类扩展出的新类。由于在Thread类中方法run()没有提供任何的操作，因此，在创建线程时用户必须覆盖方法run()来完成有用的工作。当线程中的方法start()被调用时，方法run()再被调用。下面的代码就是通过扩展Thread类来实现线程：
import java.awt.*;
class Sample1{
public static void main(String[] args){
Mythread test1=new Mythread(1);
Mythread test2=new Mythread(2);
test1.start();
test2.start();
}
}
class Mythread extends Thread {
int id;
Mythread(int i)
{ id=i;}
public void run() {
int i=0;
while(id+i==1){
try {sleep(1000);
} catch(InterruptedException e) {}
}
System.out.println(“The id is ”+id);
} |
通常当用户希望一个类能运行在自己的线程中，同时也扩展其它某些类的特性时，就需要借助运行Runnable接口来实现。Runnable接口只有一个方法run()。不论什么时候创建了一个使用Runnable接口的类，都必须在类中编写run()方法来覆盖接口中的run()方法。例如下面的代码就是通过Runnable接口实现的线程：
import java.awt.*;
import java.applet.Applet;
public class Bounce extends Applet implements Runnable{
static int r=30;
static int x=100;
static int y=30;
Thread t;
public void init()
{
t = new Thread(this);
t.start();
}
public void run()
{
int y1=+1;
int i=1;
int sleeptime=10;
while(true)
{
y+=(i*y);
if(y-rgetSize().height)
y1*=-1;
try{
t.sleep(sleeptime);
}catch(InterruptedException e){ }
}}
} |
为什么要使用线程池
在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM里创建太多的线程，可能会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。
线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使应用程序响应更快。另外，通过适当地调整线程池中的线程数目可以防止出现资源不足的情况。
创建一个线程池
一个比较简单的线程池至少应包含线程池管理器、工作线程、任务队列、任务接口等部分。其中线程池管理器（ThreadPool Manager）的作用是创建、销毁并管理线程池，将工作线程放入线程池中；工作线程是一个可以循环执行任务的线程，在没有任务时进行等待；任务队列的作用是提供一种缓冲机制，将没有处理的任务放在任务队列中；任务接口是每个任务必须实现的接口，主要用来规定任务的入口、任务执行完后的收尾工作、任务的执行状态等，工作线程通过该接口调度任务的执行。下面的代码实现了创建一个线程池，以及从线程池中取出线程的操作：
…
//create threads
synchronized(workThreadVector)
{
for(int j = 0; j < i; j )
{
threadNum ;
WorkThread workThread = new WorkThread(taskVector, threadNum);
workThreadVector.addElement(workThread);
}
}
… |
线程池适合应用的场合
当一个Web服务器接受到大量短小线程的请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率。但如果线程要求的运行时间比较长，此时线程的运行时间比创建时间要长得多，单靠减少创建时间对系统效率的提高不明显，此时就不适合应用线程池技术，需要借助其它的技术来提高服务器的服务效率
518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
