「java应用原理」简述java的运行原理
今天给各位分享java应用原理的知识，其中也会对简述java的运行原理进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
你知道java的运行原理是什么吗
Java这一语言的执行过程也遵循这样的过程：源代码---机器码。 但是，从源代码到机器码之间，究竟经过什么样的过程，则是Java独一无二的了。宽泛地讲，Java源代码（.java)经过java编译器（javac.exe）编译之后，并没有直接转化为机器码，而是转化成一种中间格式，成为字节码(.class)，字节码再经过java虚拟机转化成特定CPU架构的机器码。也正是因为这一中间物，java才有所谓的跨平台。在windows平台上编译好的字节码，copy到linux平台后，经过为linux而设计的Java虚拟机解释后即可执行。跨平台这一特征，是通过字节码和JVM来实现的。
因此，想搞清楚java程序到底是如何运行的，重点在于弄明白字节码是如何被转化成跟CPU架构相关的机器码然后被执行的。也就是要理解JVM到底是如何工作的。在了解JVM之前，我们再跳出来一下，先看看什么是虚拟机。所谓虚拟机，我是这么理解的：用软件的方式模拟出跟硬件类似的环境，比如说寄存器、存储器等等。当然，所有最终的工作还是由原来的CPU来完成。比如说VirtualBox这个虚拟机产品，它其实就是一个应用程序，用某种编程语言编写的应用程序。当运行这个应用程序时，它会要求操作系统给它独立施展手脚的空间：给我一些内存，给我一定的CPU时间片，然后不用管我了。你可能会问，寄存器是硬件啊，它怎么能划分啊，难道是时间划分？不是的，像内存这样的硬件，可以给虚拟机一块独立的内存块，但是寄存器之后的，则需要用“模拟仿真”的方式来模拟。OK，回到Java虚拟机。到底什么是Java虚拟机，很难有一个十分明确的定义，狭窄一点说，它就是一个应用程序，大部分用C++编写的。宽泛地说，它就是执行字节码的一整个环境。
深入探索Java工作原理：JVM，内存回收及其他
Java语言引入了Java虚拟机 具有跨平台运行的功能 能够很好地适应各种Web应用 同时 为了提高Java语言的性能和健壮性 还引入了如垃圾回收机制等新功能 通过这些改进让Java具有其独特的工作原理
．Java虚拟机
Java虚拟机（Java Virtual Machine JVM）是软件模拟的计算机 它可以在任何处理器上（无论是在计算机中还是在其他电子设备中）安全兼容地执行保存在 class文件中的字节码 Java虚拟机的 机器码 保存在 class文件中 有时也可以称之为字节码文件
Java程序的跨平台特性主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设备上运行 Java虚拟机中的Java解释器负责将字节码文件解释成为特定的机器码进行运行 因此在运行时 Java源程序需要通过编译器编译成为 class文件
Java虚拟机的建立需要针对不同的软硬件平台来实现 既要考虑处理器的型号 也要考虑操作系统的种类 由此在SPARC结构 X 结构 MIPS和PPC等嵌入式处理芯片上 在UNIX Linux Windows和部分实时操作系统上都可实现Java虚拟机
．无用内存自动回收机制
在程序的执行过程中 部分内存在使用过后就处于废弃状态 如果不及时进行回收 很有可能会导致内存泄漏 进而引发系统崩溃 在C++语言中是由程序员进行内存回收的 程序员需要在编写程序时把不再使用的对象内存释放掉 这种人为管理内存释放的方法往往由于程序员的疏忽而致使内存无法回收 同时也增加了程序员的工作量 而在Java运行环境中 始终存在着一个系统级的线程 专门跟踪内存的使用情况 定期检测出不再使用的内存 并自动进行回收 避免了内存的泄露 也减轻了程序员的工作量
．代码安全性检查机制
安全和方便总是相对矛盾的 Java编程语言的出现使得客户端计算机可以方便地从网络上上传或下载Java程序到本地计算机上运行 但是如何保证该Java程序不携带病毒或者没有其他危险目的呢？为了确保Java程序执行的安全性 Java语言通过Applet程序来控制非法程序的安全性 也就是有了它才确保Java语言的生存
Java字节码的执行需要经过以下 个步骤
（ ）由类装载器（class loader）负责把类文件（ class文件）加载到Java虚拟机中 在此过程需要检验该类文件是否符合类文件规范
（ ）字节码校验器（bytecode verifier）检查该类文件的代码中是否存在着某些非法操作 例如Applet程序中写本地计算机文件系统的操作
（ ）如果字节码校验器检验通过 由Java解释器负责把该类文件解释成为机器码进行执行
注意
Java虚拟机采用 沙箱 运行模式 即把Java程序的代码和数据都限制在一定内存空间里执行 不允许程序访问该内存空间以外的内存 如果是Applet程序 还不允许访问客户端机器的文件系统
Java的运行环境
无论哪种语言都需要有它特定的运行环境 也就是平台 Java语言同样不例外 但是如何理解Java程序与硬件环境无关呢？
几乎所有的语言都需要通过编译或者解释才可以被计算机执行 但是Java有一点不同 它同时需要这两个过程 其实 也正是因为这个原因才使Java这种语言具有了平台无关性 当完成一个Java源程序后 首先 通过Java翻译程序将它编译成一种叫做字节码的中间代码 然后再由Java平台的解释器将它转换成为机器语言来执行 这一平台的核心就是JVM
Java的编译过程与其他的语言不同 像C++这样的语言 在编译时它是与计算机的硬件平台信息密不可分的 编译程序通过查表将所有指令的操作数和操作码等转换成内存的偏移量 即程序运行时的内存分配方式 目的是保证程序正常运行 而Java却是将指令转换成为一种 class的文件 这种文件不包含硬件的信息 需要执行时只要经过安装有JVM的机器进行解释 创建内存分配后再通过查表来确定一条指令所在的地址 这样就有效地保证了Java的可移植性和安全性
Java平台具有这样的特性和它的结构有关 通常一个程序运行的平台是一个硬件或者软件运行的环境 目前比较流行的是Windows XP Linux Solaris和MacOS Java的平台不太一样 它由两个部分组成 即JVM和应用程序设计接口
．JVM
JVM是Java平台的核心 为了让编译产生的字节码能更好地解释与执行 因此把JVM分成了 个部分 JVM解释器 指令系统 寄存器 栈 存储区和碎片回收区
◆JVM解释器 即这个虚拟机处理字段码的CPU
◆JVM指令系统 该系统与计算机很相似 一条指令由操作码和操作数两部分组成 操作码为 位二进制数 主要是为了说明一条指令的功能 操作数可以根据需要而定 JVM有多达 种不同的操作指令
◆寄存器 JVM有自己的虚拟寄存器 这样就可以快速地与JVM的解释器进行数据交换 为了功能的需要 JVM设置了 个常用的 位寄存器 pc（程序计数器） optop（操作数栈顶指针） frame（当前执行环境指针）和vars（指向当前执行环境中第一个局部变量的指针）
◆JVM栈 指令执行时数据和信息存储的场所和控制中心 它提供给JVM解释器运算所需要的信息
◆存储区 JVM存储区用于存储编译过后的字节码等信息
◆碎片回收区 JVM碎片回收是指将使用过的Java类的具体实例从内存进行回收 这就使得开发人员免去了自己编程控制内存的麻烦和危险 随着JVM的不断升级 其碎片回收的技术和算法也更加合理 JVM 版后产生了一种叫分代收集技术 简单来说就是利用对象在程序中生存的时间划分成代 以此为标准进行碎片回收
．Java应用程序设计接口
Java Application Programming Interface简称Java API 其中文名为Java应用程序设计接口 它是一个软件集合 其中有许多开发时所需要的控件 可以用它来辅助开发
lishixinzhi/Article/program/Java/hx/201311/26733
java运行原理
Java实在”虚拟机“上进行的编译和运行。
解释：在Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码(ByteCode)（class文件的内容），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。
Java线程的概念与原理
一 操作系统中线程和进程的概念
现在的操作系统是多任务操作系统 多线程是实现多任务的一种方式
进程是指一个内存中运行的应用程序 每个进程都有自己独立的一块内存空间 一个进程中可以启动多个线程 比如在Windows系统中 一个运行的exe就是一个进程 线程是指进程中的一个执行流程 一个进程中可以运行多个线程 比如java exe进程中可以运行很多线程 线程总是属于某个进程 进程中的多个线程共享进程的内存 同时 执行是人的感觉 在线程之间实际上轮换执行
二 Java中的线程
在Java中 线程 指两件不同的事情
java lang Thread类的一个实例
线程的执行
使用java lang Thread类或者java lang Runnable接口编写代码来定义 实例化和启动新线程 一个Thread类实例只是一个对象 像Java中的任何其他对象一样 具有变量和方法 生死于堆上 Java中 每个线程都有一个调用栈 即使不在程序中创建任何新的线程 线程也在后台运行着 一个Java应用总是从main()方法开始运行 mian()方法运行在一个线程内 它被称为主线程 一旦创建一个新的线程 就产生一个新的调用栈 线程总体分两类 用户线程和守候线程
当所有用户线程执行完毕的时候 JVM自动关闭 但是守候线程却不独立于JVM 守候线程一般是由操作系统或者用户自己创建的
———————————MultiT java——————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
mt start();
int index= ;
while(true) //显示结果与教程不同
{
if(index++== )
break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread extends Thread
{
public void run()
{
while(true)
{
System out println(getName());
yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
——————————————————————————————————————
——————————MultiThread java———————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//new Thread(mt) start(); //创建多个同样的线程访问同一个变量index 若MyThread采用继承Thread方式 则无法共享同一个变量
//new Thread(mt) start();
//new Thread(mt) start();
//new Thread(mt) start();
mt getThread() start(); //也可以采用内部类的方式共享访问同一个变量
mt getThread() start();
mt getThread() start();
mt getThread() start();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
//mt start();
int index= ;
while(true) //显示结果与教程不同
{
// if(index++== )
// break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread //implements Runnable //extends Thread //使用外部类的方式
//使用内部类完成使用Runnable接口才能完成的两个功能 a 创建多个线程 b 访问同一个变量
{
int index= ;
private class InnerThread extends Thread //不想让外部访问其实现方法 加上private
{
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
}
}
}
Thread getThread()
{
return new InnerThread();
}
/*
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
//yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
*/
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
//如果不需要修改Thread类的除了run方法外的其他方法 选用implements Runnable
———————————————————————————————————————
———————————TicketsSystem java———————————————————
//多线程实现火车票的售票系统 用同步块 或著同步方法
class TicketsSystem
{
public static void main(String[] args) //运行结果与教程中不同 不完全顺序 每次运行 顺序都不完全一样
{
SellThread st=new SellThread();//创建四个线程访问同一变量tickets
// 错 SellThread st =new SellThread();//若采用创建四个对象的方式 则每个对象中都有 张票
new Thread(st) start(); //b为false 用的同步方法 | //同步方法与同步块共用中 显示的是只调用了同步块 而同步方法未被调用
//b为true 用的同步块 | //原因 启动第一个线程后 CPU时间片没有到期 线程没有立即运行 接着执行b=true
// | //解决办法 启动第一个线程后 执行一个睡眠时间 让CPU时间片到期
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
st b=true;
new Thread(st) start();
//new Thread(st) start();
//new Thread(st) start();
}
}
class SellThread implements Runnable //程序有点小问题 当剩下最后一张票时 四个线程都运行 可能会出现票数为 （系统长时间运行时）
//可加上一个静态方法sleep();它会抛出异常
{
int tickets= ;
//Object obj=new Object();//也可以声明一个Thread对象
Thread th=new Thread();
boolean b=false;
public void run()
{
if(b==false)
{
while(true)
sell();
}
else
{
while(true)
{ //同步方法利用的是this所代表的对象的锁
synchronized(this) //采用同步后 显示正确 此方法两步 声明Thread对象 用synchronized把原方法括起来
{ //这里换th为this
///*
if(tickets )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( th +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
//*/
}
}
}
}
public synchronized void sell() //每个class也有一个锁 是这个class所对应的class对象的锁（监视器）
{
if(tickets )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( sell +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
}
}
————————————————————————————————————————
———————————TestWN java————————————————————
class Test
{
public static void main(String[] args)
{
Queue q=new Queue();
Producer p=new Producer(q);
Consumer c=new Consumer(q);
p start();
c start();
}
}
class Producer extends Thread
{
Queue q;
Producer(Queue q)
{
this q=q;
}
public void run()
{
for(int i= ;i ;i++)
{
q put(i);
System out println( Producer put: +i);
}
}
}
class Consumer extends Thread
{
Queue q;
Consumer(Queue q)
{
this q=q;
}
public void run()
{
while(true)
{
System out println( Consumer get: +q get());
}
}
}
class Queue //wait notify 方法必须用在同步方法中 要加上关键字synchronized
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
if(!bFull)
{
value=i;
bFull=true;
notify();
}
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
public synchronized int get()
{
if(!bFull)
{
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
bFull=false;
notify();
return value;
}
}
————————————————————————————————————
————————————TestThread java———————————————————————
class TestThread
{
public static void main(String[] args)
{
Thread t =new Thread ();
t start();
int index= ;
while(true)
{
if(index++== )
{
t stopThread();
t interrupt(); //让线程 终止
break;
}
System out println(Thread currentThread() getName());
}
System out println( main() exit );
}
}
class Thread extends Thread
{
private boolean bStop=false;
public synchronized void run()
{
while(!bStop)
{
try
{
wait(); //加入wait后 main线程结束时 程序还未终止 原因是Thread 的线程调用wait方法 进入对象的等待队列中 需要notify方法将它唤醒
}
catch(Exception e)
{
//e printStackTrace();
if(bStop)
return;
}
System out println(getName());
}
}
public void stopThread()
{
bStop=true;
}
}
lishixinzhi/Article/program/Java/gj/201311/27407
java 运行原理是什么？
java有一个垃圾回收机制，总是在内存剩余大概5%才启动，因为它中断权限最高，它运行，其他全部停止，因此，我们不希望垃圾回收机制频繁启动，那么就要控制内存不要触碰剩余5%底线。
而在普通JavaBeans系统中，每一次客户端请求访问时，系统总是new一个javabeans或Java Class，如果并发访问量很大，比如并发10人或100人，再加上你的系统复杂，有很多JavaBeans，假设有30个，那么这下子100个并发请求来，就有3000个Java对象创建，然后下一批有来一次100个请求，这象潮水一样。
每次请求产生的3000个对象会继续占用内存，不会被垃圾回收机制回收，因为垃圾回收机制只有等到内存剩余5%才启动，这样，你的内存无论多大，取决于访问量，总会被耗光，最后垃圾回收出来收拾残局，你的业务系统被暂停甚至缓慢。
所以，这里需要有资源控制，将内存能够控制住，不要被无限消耗，最后导致垃圾回收启动，造成系统好像死机。
控制资源就是使用Pool或Cache来控制，Spring/JdonFramework下可自行加入； EJB已经默认加入了。
这也是我一直反对使用Jsp+JavaBeans来写复杂或大访问量的系统，至于如何控制服务器资源，只有数据库连接池是不够的，因为Bean才是真正的资源消耗重点。
如果你理论上属于无知，又狂热追求Spring这些新玩艺（当初），那么，即使你使用Spring，性能还是和Jsp+JavaBeans一样，在大访问量情况下经常死机，因为Spring里面需要手工配置Pool或Cache这些资源控制机制。
如果说Java比C方便，因为对象使用之后不需要清理，那么有了Ioc/DI依赖注射以后，Java中对象使用之前也不需要创建了。
spring 的好处，不用创建javabean对象了。
关于java应用原理和简述java的运行原理的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。