java程序的 增加,删除,查询 的基本原理是什么

我有些不太理解你的"基本原理"的意思 如果说一个基本原理的话 那么它涵盖的方面很多

我想你大概指的是运行原理吧

Java的运行机制是虚拟机JVM

一个Java程序的源代码被编译之后会编程一种叫做字节码的二进制文件

然后通过调用Java虚拟机来运行这个代码实时的解释成本机代码

比如你在Windows上运行Java虚拟机来运行字节码 他会转成Windows上的代码而Linux上的虚拟机会转成Linux认识的代码

不知道这样回答您是否满意

一 *** 作系统中线程和进程的概念

现在的 *** 作系统是多任务 *** 作系统 多线程是实现多任务的一种方式

进程是指一个内存中运行的应用程序 每个进程都有自己独立的一块内存空间 一个进程中可以启动多个线程 比如在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完美的解决了这个问题，JAVA是如何做到这一点的呢？在上图中我们可以看到JAVA代码执行的流程。

JAVA源代码->JAVA字节码->JVM解释执行

我们写的JAVA源代码会被编译为字节码，然后被JVM虚拟机解释执行，我们可以看到JVM虚拟机在跨平台的过程中发挥了重要的作用，就是由它解释字节码并执行的，对应于每一个平台都有一个JVM虚拟机，而字节码只有一份，windows的JVM虚拟机可以将字节码解释为能在windows平台上执行的指令并执行，Linux的JVM虚拟机可以将字节码解释为能在Linux平台上执行的指令并执行，他们执行的字节码都是同一份。这样就实现了跨平台。

你可以参考一下下面的自定义实现：

通过判断线程的方式可以实现可重入锁的构造

public class LockTest03 {

ReLock lock = new ReLock();

public void a() throws InterruptedException {

locklock();

Systemoutprintln(lockgetHoldCount());

doSomething();

lockunlock();

Systemoutprintln(lockgetHoldCount());

}

//不可重入

public void doSomething() throws InterruptedException {

locklock();

Systemoutprintln(lockgetHoldCount());

//

lockunlock();

Systemoutprintln(lockgetHoldCount());

}

public static void main(String[] args) throws InterruptedException {

LockTest03 test = new LockTest03();

testa();

Threadsleep(1000);

Systemoutprintln(testlockgetHoldCount());

}

}

// 可重入锁

class ReLock{

//是否占用

private boolean isLocked = false;

private Thread lockedBy = null; //存储线程

private int holdCount = 0;

//使用锁

public synchronized void lock() throws InterruptedException {

Thread t = ThreadcurrentThread();

while(isLocked && lockedBy != t) {

wait();

}

isLocked = true;

lockedBy = t;

holdCount ++;

}

//释放锁

public synchronized void unlock() {

if(ThreadcurrentThread() == lockedBy) {

holdCount --;

if(holdCount ==0) {

isLocked = false;

notify();

lockedBy = null;

}

}

}

public int getHoldCount() {

return holdCount;

}

}

有一个上下文的概念。

所谓jvm垃圾回收机制其实就是相较于于c、c++语言的优势之一是自带垃圾回收器，垃圾回收是指不定时去堆内存中清理不可达对象。垃圾收集器在一个Java程序中的执行是自动的，不能强制执行，程序员唯一能做的就是通过调用Systemgc 方法来建议执行垃圾收集器。

运行时类型识别(Run-timeTypeIdentification,RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。

要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。

类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的class文件中。

在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class对象是否已经加载，如果尚未加载，JVM就会根据类名查找class文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。

一般的RTTI形式包括三种：1传统的类型转换。

如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。

2通过Class对象来获取对象的类型。

如Classc=ClassforName(“Apple”);Objecto=cnewInstance();3通过关键字instanceof或ClassisInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是instanceof/ClassisInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals()/==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。

反射如果不知道某个对象的类型，可以通过RTTI来获取，但前提是这个类型在编译时必须已知，这样才能使用RTTI来识别。

即在编译时，编译器必须知道所有通过RTTI来处理的类。

使用反射机制可以不受这个限制，它主要应用于两种情况，第一个是“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。

这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。

这种配置要求构件都是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。

当处理GUI时间的构件时还必须暴露相关方法的细细，以便RAD环境帮助程序员覆盖这些处理事件的方法。

在这里，就要用到反射的机制来检查可用的方法并返回方法名。

Java通过JavaBeans提供了基于构件的编程架构。

第二种情况，在运行时获取类的信息的另外一个动机，就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。

这被成为远程调用(RMI)，它允许一个Java程序将对象分步在多台机器上，江苏java培训>

以上就是关于java程序的 增加,删除,查询 的基本原理是什么全部的内容，包括:java程序的 增加,删除,查询 的基本原理是什么、Java线程的概念与原理、java的跨平台工作原理等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！