Java.lang的研究(分析包含的重要类和接口）

Java.lang包是Java中使用最广泛的一个包，它包含很多定义的类和接口。

　　java.lang包包括以下这些类：

Boolean	Byte	Character	Class	ClassLoader	Compiler	Double	Enum	Float
InheritableThreadLocal	Integer	Long	Math	Number	Object	Package	Process	ProcessBuilder
Runtime	RuntimePermission	SecurityManager	Short	StackTraceElement	StrictMath	String	StringBuffer	StringBuilder
System	Thread	ThreadGroup	ThreadLocal	Throwable	void

　　java.lang包括以下这些接口：

Appendalbe

Comparable

Runnable

CharSequence

Iterable

Cloneable

Readable

1、在Float和Double中提供了isInfinite()和isNaN()方法，用来检验两个特殊的double和float值：无穷值和NaN（非数字)。

2、Process抽象类。抽象的Process类封装了一个进程 process, 即一个执行程序，它主要作为对象类型的超类，该对象由Runtime类中的exec()方法创建，或由ProcessBuilder类中的start()创建。

3、Runtime类。Runtime类封装运行时的环境。一般不能实例化一个Runtime对象，但是可以通过调用静态方法Runtime.getRuntime()得到一个当前Runtime对象的引用。一旦获得当前Runtime对象的引用，就可以调用几个方法来控制Java虚拟机的状态和行为。Runtime类中比较常用的几个方法：

　　　　　　 Process exec(String progName) throws IOException  作为一个单独的进程执行progName指定的程序。返回一个描述新进程的Process类的对象。

　　　　　　 long freeMemory()                                              返回Java运行时系统可以利用的空闲内存的近似字节数。

　　　　　　 void gc() 　　　　　　　　　　　　　　　　  　　　　开始垃圾回收。

　　　　       long totalMemory()                                            返回程序可以利用的类存总字节数。

使用exec()执行其他程序：　　　　

 package com.hujianjie.demo;

 public class EcecDemo {

     /**
      * 利用exec()打开指定的程序
      */
     public static void main(String[] args) {
         Runtime r = Runtime.getRuntime();
         Process p = null;
         try{
             p = r.exec("D:\\Program Files\\Dev-Cpp\\devcpp.exe");
         }catch(Exception e){
             e.printStackTrace();
             System.out.println("Error");
         }
     }

 }

4、System类。System类比较常用，其中容易忽略的是currentTimeMillis()方法是为程序执行计时；arraycopy()方法可以迅速从一个地方将任何类型的数组复制到另一个地方，其与等价的循环相比，该方法快很多；getProperty()方法可以得到不同环境变量的值。

5、Runnable接口、Thread和ThreadGroup类支持多线程编程。Runnable接口必须由一个可以启动单独的执行线程的类实现，Runnable接口只定义了一个抽象方法run(),它是线程的入口点，创建线程必须实现该方法。 Thread 类创建一个新的执行线程，它定义了下面常用的构造函数：

　　　　　　　　　　　　　　　　

 Thread()
 Thread(Runnable threadOb)
 //threadOb是实现Runnable接口的类的一个实例，它定义了线程在何处开始执行
 //线程的名称由threadName指定
 Thread(Runnable threadOb, String threadName)
 Thread(String threadName)
 Thread(ThreadGroup groupOb, Runnable threadOb)
 Thread(ThreadGroup groupOb, Runnable threadOb, String threadName)
 Thread(ThreadGroup groupOb, String threadName)

下面的程序创建了两个具有线程的线程组，演示了线程组的用法：

 package com.hujianjie.demo;

 class NewThread extends Thread{
     boolean suspendFlag;
     NewThread(String threadname, ThreadGroup tgob){
         super(tgob,threadname);
         System.out.println("New thread:"+this);
         suspendFlag =false;
         start();//Start the thread
     }
     public void run(){
         try{
             for(int i =6;i>0;i--){
                 System.out.println(getName()+": "+i);
                 Thread.sleep(1000);
                 synchronized(this){
                     while(suspendFlag){
                         wait();
                     }
                 }
             }
         }catch(Exception e){
             System.out.println("Exception in "+getName());
         }
         System.out.println(getName()+" exiting.");
     }
     void mysuspend(){
         suspendFlag = true;
     }
     synchronized void myresume(){
         suspendFlag = false ;
         notify();
     }

 }

 public class ThreadGroupDemo {

     /**
      * @param args
      */
     public static void main(String[] args) {
         ThreadGroup groupA = new ThreadGroup("Group A");
         ThreadGroup groupB = new ThreadGroup("Group B");
         NewThread ob1 = new NewThread("One",groupA);
         NewThread ob2 = new NewThread("Two",groupA);
         NewThread ob3 = new NewThread("Three",groupB);
         NewThread ob4 = new NewThread("Four",groupB);
         System.out.println("\nHere is output from list():");
         groupA.list();
         groupB.list();
         System.out.println();
         System.out.println("Suspending Group A");
         Thread tga[] = new Thread[groupA.activeCount()];
         groupA.enumerate(tga);
         for(int i=0;i<tga.length;i++){
             ((NewThread)tga[i]).mysuspend();  //suspend threads in group
         }
         try{
             Thread.sleep(4000);
         }catch(Exception e){
             System.out.println("Main thread interrupted.");
         }
         System.out.println("Resuming Group A");
         for(int i=0;i<tga.length;i++){
             ((NewThread)tga[i]).myresume();  //resume threads in group
         }
         try{
             System.out.println("Waiting for threads to finish.");
             ob1.join();
             ob2.join();
             ob3.join();
             ob4.join();
         }catch(Exception e){
             System.out.println("Exception in Main thread!");
         }
         System.out.println("Main thread exiting!");
     }

 }

运行的结果如下：

 New thread:Thread[One,5,Group A]
 New thread:Thread[Two,5,Group A]
 One: 6
 New thread:Thread[Three,5,Group B]
 Two: 6
 New thread:Thread[Four,5,Group B]
 Three: 6

 Here is output from list():
 Four: 6
 java.lang.ThreadGroup[name=Group A,maxpri=10]
     Thread[One,5,Group A]
     Thread[Two,5,Group A]
 java.lang.ThreadGroup[name=Group B,maxpri=10]
     Thread[Three,5,Group B]
     Thread[Four,5,Group B]

 Suspending Group A
 Four: 5
 Three: 5
 Four: 4
 Three: 4
 Four: 3
 Three: 3
 Resuming Group A
 Two: 5
 Waiting for threads to finish.
 One: 5
 Four: 2
 Three: 2
 Two: 4
 One: 4
 Four: 1
 Three: 1
 Two: 3
 One: 3
 Four exiting.
 Three exiting.
 Two: 2
 One: 2
 Two: 1
 One: 1
 One exiting.
 Two exiting.
 Main thread exiting!