Thread和Runnable区别_中华文本库
第1页/共3页
一：类本身区别
Thread需要实现Runnable ,Runnable没有start()方法，只有Thread类中才有
public interface Runnable
Public class Thread implements Runnable
二：创建线程两种方式
一种是继承Thread类，一种是实现Runnable接口
class MyThread extends Thread{
public void run(){
class MyThread implements Runnable {
public void run(){
三：启动线程两种方式
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程 二是写一个类实现Runnable接口,实现里面的run方法,用
new Thread(Runnable target).start()方法来启动
四：线程与多线程
简单的调用run方法,如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了。
如果用start()方式来启动，这时线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样
public class ThreadDemo01 {
public static void main(String[] args) {
第1页/共3页
寻找更多 ""Java中继承thread类与实现Runnable接口的区别
Java中继承thread类与实现Runnable接口的区别
&&& 在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看一下这两种方式实现的两种结果。Java代码 &package&com.&&class&MyThread&extends&Thread{&&&&&&&&&&&&private&int&ticket&=&10;&&&&&&private&String&&&&&&&public&MyThread(String&name){&&&&&&&&&&this.name&=&&&&&&}&&&&&&&&&&&&public&void&run(){&&&&&&&&&&for(int&i&=0;i&500;i++){&&&&&&&&&&&&&&if(this.ticket&0){&&&&&&&&&&&&&&&&&&System.out.println(this.name+"卖票----&"+(this.ticket--));&&&&&&&&&&&&&&}&&&&&&&&&&}&&&&&&}&&}&&public&class&ThreadDemo&{&&&&&&&&&&&&&&public&static&void&main(String[]&args)&{&&&&&&&&&&MyThread&mt1=&new&MyThread("一号窗口");&&&&&&&&&&MyThread&mt2=&new&MyThread("二号窗口");&&&&&&&&&&MyThread&mt3=&new&MyThread("三号窗口");&&&&&&&&&&mt1.start();&&&&&&&&&&mt2.start();&&&&&&&&&&mt3.start();&&&&&&}&&&&}&&&运行结果如下：Java代码 &一号窗口卖票----&10&&一号窗口卖票----&9&&二号窗口卖票----&10&&一号窗口卖票----&8&&一号窗口卖票----&7&&一号窗口卖票----&6&&三号窗口卖票----&10&&一号窗口卖票----&5&&一号窗口卖票----&4&&一号窗口卖票----&3&&一号窗口卖票----&2&&一号窗口卖票----&1&&二号窗口卖票----&9&&二号窗口卖票----&8&&三号窗口卖票----&9&&三号窗口卖票----&8&&三号窗口卖票----&7&&三号窗口卖票----&6&&三号窗口卖票----&5&&三号窗口卖票----&4&&三号窗口卖票----&3&&三号窗口卖票----&2&&三号窗口卖票----&1&&二号窗口卖票----&7&&二号窗口卖票----&6&&二号窗口卖票----&5&&二号窗口卖票----&4&&二号窗口卖票----&3&&二号窗口卖票----&2&&二号窗口卖票----&1&&&通过实现Runnable接口的代码如下：&Java代码 &package&com.&&class&MyThread1&implements&Runnable{&&&&&&private&int&ticket&=10;&&&&&&private&String&&&&&&&public&void&run(){&&&&&&&&&&for(int&i&=0;i&500;i++){&&&&&&&&&&&&&&if(this.ticket&0){&&&&&&&&&&&&&&&&&&System.out.println(Thread.currentThread().getName()+"卖票----&"+(this.ticket--));&&&&&&&&&&&&&&}&&&&&&&&&&}&&&&&&}&&}&&public&class&RunnableDemo&{&&&&&&&&&&&&&&public&static&void&main(String[]&args)&{&&&&&&&&&&//&TODO&Auto-generated&method&stub&&&&&&&&&&//设计三个线程&&&&&&&&&&&MyThread1&mt&=&new&MyThread1();&&&&&&&&&&&Thread&t1&=&new&Thread(mt,"一号窗口");&&&&&&&&&&&Thread&t2&=&new&Thread(mt,"二号窗口");&&&&&&&&&&&Thread&t3&=&new&Thread(mt,"三号窗口");&&//&&&&&&&&&MyThread1&mt2&=&new&MyThread1();&&//&&&&&&&&&MyThread1&mt3&=&new&MyThread1();&&&&&&&&&&&t1.start();&&&&&&&&&&&t2.start();&&&&&&&&&&&t3.start();&&&&&&}&&&&}&&&运行结果如下：Java代码 &一号窗口卖票----&10&&三号窗口卖票----&9&&三号窗口卖票----&7&&三号窗口卖票----&5&&三号窗口卖票----&4&&三号窗口卖票----&3&&三号窗口卖票----&2&&三号窗口卖票----&1&&一号窗口卖票----&8&&二号窗口卖票----&6&&&&&&&&为什么会出现这种结果呐。我们不妨做个比喻，其实刚的程序，继承Thread类的，我们相当于拿出三件事即三个卖票10张的任务分别分给三个窗口，他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建三个对象的同时创建了三个线程；实现Runnable的， 相当于是拿出一个卖票10张得任务给三个人去共同完成，new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。&&&&& 用图表示如下：&&& 在我们刚接触的时候可能会迷糊继承Thread类和实现Runnable接口实现多线程，其实在接触后我们会发现这完全是两个不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。&&&&& &&& 其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了。&&&&&& &&& 大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类。 &&
发表评论：
TA的最新馆藏[转]&[转]&Java中线程的创建有两种方式：
1．& 通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中
2．& 通过实现Runnable接口，实例化Thread类
&&& 在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看一下这两种方式实现的两种结果。
package&com.dr.class&MyThread3&extends&Thread{&&&&&&&&private&int&ticket&=&10;&&&&private&String&&&&&public&MyThread3(String&name){&&&&&&&&this.name&=&&&&}&&&&&&&&public&void&run(){&&&&&&&&for(int&i&=0;i&500;i++){&&&&&&&&&&&&if(this.ticket&0){&&&&&&&&&&&&&&&&System.out.println(this.name+"卖票----&"+(this.ticket--));&&&&&&&&&&&&}&&&&&&&&}&&&&}}public&class&Demo07&{&&&&&&&&public&static&void&main(String[]&args)&{&&&&&&&&MyThread3&mt1=&new&MyThread3("一号窗口");&&&&&&&&MyThread3&mt2=&new&MyThread3("二号窗口");&&&&&&&&MyThread3&mt3=&new&MyThread3("三号窗口");&&&&&&&&mt1.start();&&&&&&&&mt2.start();&&&&&&&&mt3.start();&&&&}}
package&com.dr.class&MyThread1&implements&Runnable{&&&&private&int&ticket&=10;&&&&private&String&&&&&public&void&run(){&&&&&&&&for(int&i&=0;i&500;i++){&&&&&&&&&&&&if(this.ticket&0){&&&&&&&&&&&&&&&&System.out.println(Thread.currentThread().getName()+"卖票----&"+(this.ticket--));&&&&&&&&&&&&}&&&&&&&&}&&&&}}public&class&Demo02&{&&&&&&&&public&static&void&main(String[]&args)&{&&&&&&&&//&TODO&Auto-generated&method&stub&&&&&&&&//设计三个线程&&&&&&&&&MyThread1&mt&=&new&MyThread1();&&&&&&&&&Thread&t1&=&new&Thread(mt,"一号窗口");&&&&&&&&&Thread&t2&=&new&Thread(mt,"二号窗口");&&&&&&&&&Thread&t3&=&new&Thread(mt,"三号窗口");//&&&&&&&&&MyThread1&mt2&=&new&MyThread1();//&&&&&&&&&MyThread1&mt3&=&new&MyThread1();&&&&&&&&&t1.start();&&&&&&&&&t2.start();&&&&&&&&&t3.start();&&&&}}
&&&& 为什么会出现这种结果呐。我们不妨做个比喻，其实刚的程序，继承Thread类的，我们相当于拿出三件事即三个卖票10张的任务分别分给三个窗口，他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建三个对象的同时创建了三个线程；实现Runnable的， 相当于是拿出一个卖票10张得任务给三个人去共同完成，new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。
&&&&& 用图表示如下
在我们刚接触的时候可能会迷糊继承Thread类和实现Runnable接口实现多线程，其实在接触后我们会发现这完全是两个不同的实现多线程，一个是多个线程分别完成自己的任务，一个是多个线程共同完成一个任务。
&&&&& 其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了。
&&&&&& 大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类。
原文摘自：
阅读(...) 评论()Java中Runnable和Thread的区别_百度知道
Java中Runnable和Thread的区别
Runnable接口和Thread类是java中实现多线程的两中方法。Thread类的构造方法有8个，但常用的只有4个，分别为：Thread类中的两个最主要的方法：（1）run()—包含线程运行时所执行的代码，即线程需要完成的任务，是线程执行体。（2）start()—用于启动线程。实现Runnable接口的类必须使用Thread类的实例才能创建线程。通过实现Runnable接口来创建并启动多线程的步骤：
其他类似问题
为您推荐：
;&MyWork());is&&&&nbsp.;&&&&class&&nbsp。我总结了大概有以下几点;&native&}&&Runnable&/*&static&&nbsp.start();{&&&lt.&&nbsp。比如 Java 内置的线程池 API ExcutorService 等;*/&&nbsp。实现 Runnable 大多数情况下是比继承 Thread 更好的方法;&nbsp.;&nbsp。其实 Thread 只是实现 Runnable 接口;}&&&&nbsp。实现 Runnable 接口 。代码如下;&MyThread&{&&nbsp，你得为你的每一部分工作都定义一个线程;&);&&public&nbsp，所以你继承了 Thread 的话;&&Thread&nbsp，多线程可以直接将你的工作并发处理（直接使用 start）;run()&&&&void&super(&&&registerNatives();&here&&{&&first&void&&your&nbsp。&registerNatives();run()&nbsp，我翻过来给你看下;class&//&}}这俩的区别讨论很多;Thread(new&{&;public&Make&&&&&nbsp.;work&&nbsp。而继承 Thread 不能直接进行多线程工作;如果实现 Runnable 接口;Runnable&nbsp。publicclass&&implements&&nbsp，我们都知道有俩种方式可以创建一个线程;implements&public&private&&MyThread&&nbsp。不信你看源码;&nbsp，其他的类你就不能继承了.;public&&nbsp.&&{&{&&Thread&{&registerNatives&nbsp。在 Java 语言中;;public&&&nbsp：//new&&&&MyThread()&&the&&nbsp。其他的一些API。Java 只支持单继承;&//&&nbsp，接口都是 Runnable 类型的;thing&clinit&&nbsp。继承 Thread 类 ;&static&&}}//Tsure&here&MyWork&&void&your&nbsp.start();&nbsp.&work&&nbsp.;&extends&nbsp，并增加了一些常用方法而已.以下是一篇简单的介绍
线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,
我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样.
你简单的调用run方法是没有这样效果的,所以你必须调用Thread类的start方法来启动你的线程.所以你启动线程有两种方法
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动
这两种方法都必须实现RU...
thread的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁[转]Java中Runnable跟Thread的区别_数据库事宜四大特性_汇编的标志位阐发__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
[转]Java中Runnable跟Thread的区别
数据库事宜四大特性
汇编的标志位阐发
[转]Java中Runnable跟Thread的区别
[转]Java中Runnable和Thread的区别
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口； Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的 run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限， 下面看例子： package org.thread. class MyThread extends Thread{ private S public MyThread(String name) { super(); this.name = } public void run(){ for(int i=0;i&10;i++){ System.out.println("线程开始："+this.name+",i="+i); } } } package org.thread. public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("线程a"); MyThread mt2=new MyThread("线程b"); mt1.run(); mt2.run(); } } 但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动 start()方法启动线程： package org.thread. public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("线程a"); MyThread mt2=new MyThread("线程b"); mt1.start(); mt2.start(); } };这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？ 在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface） ·Runnable接口 在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。 public interface Runnable{ public void run(); } 例子： package org.runnable. class MyThread implements Runnable{ private S public MyThread(String name) { this.name = } public void run(){ for(int i=0;i&100;i++){ System.out.println("线程开始："+this.name+",i="+i); } } }; 但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer) 此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多 线程。（start()可以协调系统的资源）: package org.runnable. import org.runnable.demo.MyT public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("线程a"); MyThread mt2=new MyThread("线程b"); new Thread(mt1).start(); new Thread(mt2).start(); } } · 两种实现方式的区别和联系： 在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比 继承Thread类有如下好处： -&避免点继承的局限，一个类可以继承多个接口。 -&适合于资源的共享 以卖票程序为例，通过Thread类完成： package org.demo. class MyThread extends Thread{ private int ticket=10; public void run(){ for(int i=0;i&20;i++){ if(this.ticket&0){ System.out.println("卖票：ticket"+this.ticket--); } } } }; 下面通过三个线程对象，同时卖票： package org.demo. public class ThreadTicket { public static void main(String[] args) { MyThread mt1=new MyThread(); MyThread mt2=new MyThread(); MyThread mt3=new MyThread(); mt1.start();//每个线程都各卖了10张，共卖了30张票 mt2.start();//但实际只有10张票，每个线程都卖自己的票 mt3.start();//没有达到资源共享 } } 如果用Runnable就可以实现资源共享，下面看例子： package org.demo. class MyThread implements Runnable{ private int ticket=10; public void run(){ for(int i=0;i&20;i++){ if(this.ticket&0){ System.out.println("卖票：ticket"+this.ticket--); } } } } package org.demo. public class RunnableTicket { public static void main(String[] args) { MyThread mt=new MyThread(); new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一 new Thread(mt).start();//个实例化对象mt，就会出现异常 new Thread(mt).start(); } }; 虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。Runnable接口和Thread之间的联系： public class Thread extends Object implements Runnable 发现Thread类也是Runnable接口的子类。
来自: /gaogaf/blog/item/dc8.html
数据库事宜四大特性
数据库事务四大特性事务的：原子性、一致性、分离性、持久性原子性、一致性、分离性、持久性(1) 原子性　 事务的原子性指的是，事务中包含的程序作为数据库的逻辑工作单位，它所做的对数据修改操作要么全部执行，要么完全不执行。这种特性称为原子性。　 事务的原子性要求，如果把一个事务可看作是一个程序，它要么完整的被执行，要么完全不执行。就是说事务的操纵序列或者完全应用到数据库或者完全不影响数据库。这种特性称为原子性。
假如用户在一个事务内完成了对数据库的更新，这时所有的更新对外部世界必须是可见的，或者完全没有更新。前者称事务已提交，后者称事务撤消（或流产）。DBMS必须确保由成功提交的事务完成的所有操纵在数据库内有完全的反映，而失败的事务对数据库完全没有影响。(2) 一致性
事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。这种特性称为事务的一致性。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。　　一致性处理数据库中对所有语义约束的保护。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。例如，当数据库处于一致性状态S1时，对数据库执行一个事务，在事务执行期间假定数据库的状态是不一致的，当事务执行结束时，数据库处在一致性状态S2。(3) 分离性　　分离性指并发的事务是相互隔离的。即一个事务内部的操作及正在操作的数据必须封锁起来，不被其它企图进行修改的事务看到。
分离性是DBMS针对并发事务间的冲突提供的安全保证。DBMS可以通过加锁在并发执行的事务间提供不同级别的分离。假如并发交叉执行的事务没有任何控制，操纵相同的共享对象的多个并发事务的执行可能引起异常情况。　　DBMS可以在并发执行的事务间提供不同级别的分离。分离的级别和并发事务的吞吐量之间存在反比关系。较多事务的可分离性可能会带来较高的冲突和较多的事务流产。流产的事务要消耗资源，这些资源必须要重新被访问。因此，确保高分离级别的DBMS需要更多的开销。(4)持久性　　持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即一旦一个事务提交，DBMS保证它对数据库中数据的改变应该是永久性的，耐得住任何系统故障。持久性通过数据库备份和恢复来保证。　　持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即对已提交事务的更新能恢复。一旦一个事务被提交，DBMS必须保证提供适当的冗余，使其耐得住系统的故障。所以，持久性主要在于DBMS的恢复性能。
http://blog.chinaunix.net/u/29238/showart_253253.html
汇编的标志位阐发
汇编的标志位阐明
1、进位标志CF(Carry Flag)进位标志CF主要用来反映运算是否产生进位或借位。如果运算结果的最高位产生了一个进位或借位，那么，其值为1，否则其值为0。使用该标志位的情况有：多字(字节)数的加减运算，无符号数的大小比较运算，移位操作，字(字节)之间移位，专门改变CF值的指令等。2、奇偶标志PF(Parity Flag)奇偶标志PF用于反映运算结果中“1”的个数的奇偶性。如果“1”的个数为偶数，则PF的值为1，否则其值为0。利用PF可进行奇偶校验检查，或产生奇偶校验位。在数据传送过程中，为了提供传送的可靠性，如果采用奇偶校验的方法，就可使用该标志位。3、辅助进位标志AF(Auxiliary Carry Flag)在发生下列情况时，辅助进位标志AF的值被置为1，否则其值为0：(1)、在字操作时，发生低字节向高字节进位或借位时；(2)、在字节操作时，发生低4位向高4位进位或借位时。对以上6个运算结果标志位，在一般编程情况下，标志位CF、ZF、SF和OF的使用频率较高，而标志位PF和AF的使用频率较低。4、零标志ZF(Zero Flag)零标志ZF用来反映运算结果是否为0。如果运算结果为0，则其值为1，否则其值为0。在判断运算结果是否为0时，可使用此标志位。5、符号标志SF(Sign Flag)符号标志SF用来反映运算结果的符号位，它与运算结果的最高位相同。在微机系统中，有符号数采用补码表示法，所以，SF也就反映运算结果的正负号。运算结果为正数时，SF的值为0，否则其值为1。6、溢出标志OF(Overflow Flag)溢出标志OF用于反映有符号数加减运算所得结果是否溢出。如果运算结果超过当前运算位数所能表示的范围，则称为溢出，OF的值被置为1，否则，OF的值被清为0。“溢出”和“进位”是两个不同含义的概念，不要混淆。如果不太清楚的话，请查阅《计算机组成原理》课程中的有关章节。二、状态控制标志位状态控制标志位是用来控制CPU操作的，它们要通过专门的指令才能使之发生改变。1、追踪标志TF(Trap Flag)当追踪标志TF被置为1时，CPU进入单步执行方式，即每执行一条指令，产生一个单步中断请求。这种方式主要用于程序的调试。指令系统中没有专门的指令来改变标志位TF的值，但程序员可用其它办法来改变其值。2、中断允许标志IF(Interrupt-enableFlag)中断允许标志IF是用来决定CPU是否响应CPU外部的可屏蔽中断发出的中断请求。但不管该标志为何值，CPU都必须响应CPU外部的不可屏蔽中断所发出的中断请求，以及CPU内部产生的中断请求。具体规定如下：(1)、当IF=1时，CPU可以响应CPU外部的可屏蔽中断发出的中断请求；(2)、当IF=0时，CPU不响应CPU外部的可屏蔽中断发出的中断请求。CPU的指令系统中也有专门的指令来改变标志位IF的值。3、方向标志DF(DirectionFlag)方向标志DF用来决定在串操作指令执行时有关指针寄存器发生调整的方向。具体规定在第5.2.11节——字符串操作指令——中给出。在微机的指令系统中，还提供了专门的指令来改变标志位DF的值。三、32位标志寄存器增加的标志位1、I/O特权标志IOPL(I/O Privilege Level)I/O特权标志用两位二进制位来表示，也称为I/O特权级字段。该字段指定了要求执行I/O指令的特权级。如果当前的特权级别在数值上小于等于IOPL的值，那么，该I/O指令可执行，否则将发生一个保护异常。2、嵌套任务标志NT(Nested Task)嵌套任务标志NT用来控制中断返回指令IRET的执行。具体规定如下：(1)、当NT=0，用堆栈中保存的值恢复EFLAGS、CS和EIP，执行常规的中断返回操作；(2)、当NT=1，通过任务转换实现中断返回。3、重启动标志RF(Restart Flag)重启动标志RF用来控制是否接受调试故障。规定：RF=0时，表示“接受”调试故障，否则拒绝之。在成功执行完一条指令后，处理机把RF置为0，当接受到一个非调试故障时，处理机就把它置为1。4、虚拟8086方式标志VM(Virtual 8086 Mode)如果该标志的值为1，则表示处理机处于虚拟的8086方式下的工作状态，否则，处理机处于一般保护方式下的工作状态。转自:/asm/flags.html
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：