精华内容
下载资源
问答
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    但是与.cs页面编译过程不同是,当浏览者第一次浏览到.aspx页面时,ASP.NET自动生成该页.NET类文件,并将其编译成另一个.DLL文件。 当浏览者再一次浏览该页面时候,生成.DLL就会在服务器上运行,并响应用户在...
  • 程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期。它因创建而产生,因调度而运行,因等待...

    第一部分:进程和程序的区别

    程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期。它因创建而产生,因调度而运行,因等待资源或事件而被处于等待状态,因完成任务而被撤消。反映了一个程序在一定的数据集上运行的全部动态过程。
    进程程序并不是一一对应的,一个程序执行在不同的数据集上就成为不同的进程,可以用进程控制块来唯一地标识每个进程。而这一点正是程序无法做到的,由于程序没有和数据产生直接的联系,既使是执行不同的数据的程序,他们的指令的集合依然是一样的,所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说,一个进程肯定有一个与之对应的程序,而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。
    进程还具有并发性和交往性,这也与程序的封闭性不同。

     

    第二部分:进程和线程的区别

         应用程序在执行过程中存在一个内存空间的初始入口点地址、一个程序执行过程中的代码执行序列以及用于标识进程结束的内存出口点地址,在进程执行过程中的每一时间点均有唯一的处理器指令与内存单元地址相对应。 
    Java语言中定义的线程(Thread)同样包括一个内存入口点地址、一个出口点地址以及能够顺序执行的代码序列。但是进程与线程的重要区别在于线程不能够单独执行,它必须运行在处于活动状态的应用程序进程中,因此可以定义线程是程序内部的具有并发性的顺序代码流。 
    Unix操作系统和Microsoft Windows操作系统支持多用户、多进程的并发执行,而Java语言支持应用程序进程内部的多个执行线程的并发执行多线程的意义在于一个应用程序的多个逻辑单元可以并发地执行。但是多线程并不意味着多个用户进程在执行,操作系统也不把每个线程作为独立的进程来分配独立的系统资源。进程可以创建其子进程,子进程与父进程拥有不同的可执行代码和数据内存空间。而在用于代表应用程序的进程中多个线程共享数据内存空间,但保持每个线程拥有独立的执行堆栈和程序执行上下文(Context)。 
    基于上述区别,线程也可以称为轻型进程 (Light Weight Process,LWP)。不同线程间允许任务协作和数据交换,使得在计算机系统资源消耗等方面非常廉价。 
    线程需要操作系统的支持,不是所有类型的计算机都支持多线程应用程序。Java程序设计语言将线程支持与语言运行环境结合在一起,提供了多任务并发执行的能力。这就好比一个人在处理家务的过程中,将衣服放到洗衣机中自动洗涤后将大米放在电饭锅里,然后开始做菜。等菜做好了,饭熟了同时衣服也洗好了。 
    需要注意的是:在应用程序中使用多线程不会增加 CPU 的数据处理能力。只有在多CPU 的计算机或者在网络计算体系结构下,将Java程序划分为多个并发执行线程后,同时启动多个线程运行,使不同的线程运行在基于不同处理器的Java虚拟机中,才能提高应用程序的执行效率

    第三部分:应用程序、进程、线程的关系


    简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程,使得多线程程序的并发性高。另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。

    线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
    从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
    进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
    线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
    一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

     

     

    第四部分:Java的内存模型和进程安全

    不同的平台,内存模型是不一样的,但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上,所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型,要解决两个主要的问题:可见性和有序性。我们都知道计算机有高速缓存的存在,处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型,屏蔽了底层平台内存管理细节,对于java开发人员,要清楚在jvm内存模型的基础上,如果解决多线程的可见性和有序性。
           那么,何谓可见性? 多个线程之间是不能互相传递数据通信的,它们之间的沟通只能通过共享变量来进行。Java内存模型(JMM)规定了jvm有主内存,主内存是多个线程共享的。当new一个对象的时候,也是被分配在主内存中,每个线程都有自己的工作内存,工作内存存储了主存的某些对象的副本,当然线程的工作内存大小是有限制的。当线程操作某个对象时,执行顺序如下:
     (1) 从主存复制变量到当前工作内存 (read and load)
     (2)
    执行代码,改变共享变量值 (use and assign)
     (3)
    用工作内存数据刷新主存相关内容 (store and write)

    JVM规范定义了线程对主存的操作指令:read,load,use,assign,store,write。当一个共享变量在多个线程的工作内存中都有副本时,如果一个线程修改了这个共享变量,那么其他线程应该能够看到这个被修改后的值,这就是多线程的可见性问题。
            那么,什么是有序性呢 ?线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。
            线程不能直接为主存中中字段赋值,它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write),至于何时同步过去,根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本,当同一线程多次重复对字段赋值时,比如:

    for(inti=0;i<10;i++)

      a++;

     


    线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区,所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x,线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作,它的执行过程如下:
    1 从主存中读取变量x副本到工作内存
    2
    x1
    3
    x1后的值写回主 存
    如果另外一个线程b执行x=x-1,执行过程如下:
    1 从主存中读取变量x副本到工作内存
    2
    x1
    3
    x1后的值写回主存 
    那么显然,最终的x的值是不可靠的。假设x现在为10,线程a加1,线程b减1,从表面上看,似乎最终x还是为10,但是多线程情况下会有这种情况发生:
    1:线程a从主存读取x副本到工作内存,工作内存中x值为10
    2
    :线程b从主存读取x副本到工作内存,工作内存中x值为10
    3
    :线程a将工作内存中x1,工作内存中x值为11
    4
    :线程ax提交主存中,主存中x11
    5
    :线程b将工作内存中x值减1,工作内存中x值为9
    6
    :线程bx提交到中主存中,主存中x9 
    同样,x有可能为11,如果x是一个银行账户,线程a存款,线程b扣款,显然这样是有严重问题的,要解决这个问题,必须保证线程a和线程b是有序执行的,并且每个线程执行的加1或减1是一个原子操作。看看下面代码:

    public class Account{
     
        private int balance;
     
        public Account(int balance) {
            this.balance = balance;
        }
     
        public int getBalance() {
            return balance;
        }
     
        public void add(int num) {
            balance = balance + num;
        }
     
        public void withdraw(int num) {
            balance = balance - num;
        }
     
        public static void main(String[] args)throws InterruptedException {
            Account account = new Account(1000);
            Thread a = new Thread(newAddThread(account, 20), "add");
            Thread b = new Thread(newWithdrawThread(account, 20), "withdraw");
            a.start();
            b.start();
            a.join();
            b.join();
            System.out.println(account.getBalance());
        }
     
        static class AddThread implements Runnable{
            Account account;
            int    amount;
     
            public AddThread(Account account, intamount) {
                this.account = account;
                this.amount = amount;
            }
     
            public void run() {
                for (int i = 0; i < 200000; i++){
                    account.add(amount);
                }
            }
        }
     
        static class WithdrawThread implementsRunnable {
            Account account;
            int    amount;
     
            public WithdrawThread(Account account,int amount) {
                this.account = account;
                this.amount = amount;
            }
     
            public void run() {
                for (int i = 0; i < 100000; i++){
                    account.withdraw(amount);
                }
            }
        }
    }


     


    第一次执行结果为10200,第二次执行结果为1060,每次执行的结果都是不确定的,因为线程的执行顺序是不可预见的。这是java同步产生的根源,synchronized关键字保证了多个线程对于同步块是互斥的,synchronized作为一种同步手段,解决java多线程的执行有序性和内存可见性,而volatile关键字之解决多线程的内存可见性问题。后面将会详细介绍。

     


    synchronized关键字 
            上面说了,java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量,这一段代码成为互斥区或临界区,为了保证共享变量的正确性,synchronized标示了临界区。典型的用法如下:

    synchronized(锁){
         临界区代码
    }


    为了保证银行账户的安全,可以操作账户的方法如下:

    public synchronizedvoid add(int num) {
         balance = balance + num;
    }
    public synchronizedvoid withdraw(int num) {
         balance = balance - num;
    }

    刚才不是说了synchronized的用法是这样的吗:

    synchronized(锁){
    临界区代码
    }

    那么对于public synchronized void add(int num)这种情况,意味着什么呢?其实这种情况,锁就是这个方法所在的对象。同理,如果方法是public  static synchronized void add(int num),那么锁就是这个方法所在的class。
            理论上,每个对象都可以做为锁,但一个对象做为锁时,应该被多个线程共享,这样才显得有意义,在并发环境下,一个没有共享的对象作为锁是没有意义的。假如有这样的代码:

    public classThreadTest{
      public void test(){
         Object lock=new Object();
         synchronized (lock){
            //do something
         }
      }
    }


    lock变量作为一个锁存在根本没有意义,因为它根本不是共享对象,每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock,根本不存在锁竞争。
            每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个被线程被唤醒 (notify)后,才会进入到就绪队列,等待cpu的调度。当一开始线程a第一次执行account.add方法时,jvm会检查锁对象account 的就绪队列是否已经有线程在等待,如果有则表明account的锁已经被占用了,由于是第一次运行,account的就绪队列为空,所以线程a获得了锁,执行account.add方法。如果恰好在这个时候,线程b要执行account.withdraw方法,因为线程a已经获得了锁还没有释放,所以线程 b要进入account的就绪队列,等到得到锁后才可以执行。
    一个线程执行临界区代码过程如下:
    1 获得同步锁
    2 清空工作内存
    3 从主存拷贝变量副本到工作内存
    4 对这些变量计算
    5 将变量从工作内存写回到主存
    6 释放锁
    可见,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。


    生产者/消费者模式 
            生产者/消费者模式其实是一种很经典的线程同步模型,很多时候,并不是光保证多个线程对某共享资源操作的互斥性就够了,往往多个线程之间都是有协作的。
            假设有这样一种情况,有一个桌子,桌子上面有一个盘子,盘子里只能放一颗鸡蛋,A专门往盘子里放鸡蛋,如果盘子里有鸡蛋,则一直等到盘子里没鸡蛋,B专门从盘子里拿鸡蛋,如果盘子里没鸡蛋,则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区,每次往盘子放鸡蛋应该都是互斥的,A的等待其实就是主动放弃锁,B 等待时还要提醒A放鸡蛋。
    如何让线程主动释放锁
    很简单,调用锁的wait()方法就好。wait方法是从Object来的,所以任意对象都有这个方法。看这个代码片段:

    Object lock=newObject();//声明了一个对象作为锁
       synchronized (lock) {
           balance = balance - num;
           //这里放弃了同步锁,好不容易得到,又放弃了
           lock.wait();
    }

    如果一个线程获得了锁lock,进入了同步块,执行lock.wait(),那么这个线程会进入到lock的阻塞队列。如果调用 lock.notify()则会通知阻塞队列的某个线程进入就绪队列。
    声明一个盘子,只能放一个鸡蛋

     

          import java.util.ArrayList;  
           import java.util.List;  
            
           public class Plate {  
            
              List<Object> eggs = new ArrayList<Object>();  
            
              public synchronized Object getEgg() {  
                  while(eggs.size() == 0) {  
                       try {  
                           wait();  
                       } catch (InterruptedException e){  
                       }  
                  }  
            
                  Object egg = eggs.get(0);  
                  eggs.clear();// 清空盘子  
                  notify();// 唤醒阻塞队列的某线程到就绪队列  
                  System.out.println("拿到鸡蛋");  
                  return egg;  
              }  
            
              public synchronized void putEgg(Object egg) {  
                  while(eggs.size() > 0) {  
                       try {  
                           wait();  
                       } catch (InterruptedException e){  
                       }  
                  }  
                  eggs.add(egg);// 往盘子里放鸡蛋  
                  notify();// 唤醒阻塞队列的某线程到就绪队列  
                  System.out.println("放入鸡蛋");  
              }  
                 
              static class AddThread extends Thread{  
                  private Plate plate;  
                  private Object egg=new Object();  
                  public AddThread(Plate plate){  
                       this.plate=plate;  
                  }  
                     
                  public void run(){  
                       for(int i=0;i<5;i++){  
                           plate.putEgg(egg);  
                       }  
                  }  
              }  
                 
              static class GetThread extends Thread{  
                  private Plate plate;  
                  public GetThread(Plate plate){  
                       this.plate=plate;  
                  }  
                     
                  public void run(){  
                       for(int i=0;i<5;i++){  
                           plate.getEgg();  
                       }  
                  }  
              }  
                 
              public static void main(String args[]){  
                  try {  
                       Plate plate=new Plate();  
                       Thread add=new Thread(newAddThread(plate));  
                       Thread get=new Thread(newGetThread(plate));  
                       add.start();  
                       get.start();  
                       add.join();  
                       get.join();  
                  } catch (InterruptedException e) {  
                       e.printStackTrace();  
                  }  
                  System.out.println("测试结束");  
              }  
           }


    参考文章:

    http://www.cnblogs.com/kunpengit/archive/2011/11/18/2254280.html

    http://www.blogjava.net/stevenjohn/archive/2012/05/22/378842.html

    http://blog.csdn.net/forlong401/article/details/8066345

     

     

     

    展开全文
  •  SessionBean: Stateless Session Bean 生命周期是由容器决定,当客户机发出请求要建立一个Bean实例时,EJB容器不一定要创建一个Bean实例供客户机调用,而是随便找一个现有实例提供给客户机。...
  • iPhone开发秘籍(2版)--源代码

    热门讨论 2012-12-11 13:51:22
    第2章 构建第一个项目 28 2.1 创建新项目 28 2.2 用模板构建Hello World应用程序 29 2.2.1 创建新项目 29 2.2.2 Project窗口 30 2.2.3 Detail窗格 31 2.2.4 编辑器窗口 32 2.2.5 查看项目 32 2.2.6 打开视图...
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    hda1中的“1”代表hda的第一个硬盘分区 (partition),hda2代表hda的第二主分区,第一个逻辑分区从hda5开始,依此类推。此外,可以直接检查 /var/log/messages文件,在该文件中可以找到计算机开机后系统已辨认出来的...
  • 3.2 创建你的第一个Java游戏——Space Blaster 48 3.2.1 了解游戏的体系结构 49 3.2.2 创建项目 50 3.2.3 创建游戏的活动类 51 3.2.4 创建游戏布局 53 3.2.5 实现游戏 58 3.2.6 处理按键和触控事件 66...
  • 五章(对象生命周期)一:类、对象和引用 类是描述类型实例在内存中什么样子,对象是...当一个对象从代码库的任何部分都不可达是,垃圾回收器会删除它。但不一定是在函数返回后立即回收。 2:CILnew指令 
    第五章(对象的生命周期)

    一:类、对象和引用
        类是描述类型的实例在内存中什么样子的,对象是在托管堆中创建的类的实例,new返回的指向对象的引用,这个引用是存放在栈里的。

    二:对象生命周期的基础
        1:法则:使用new关键字将一个对象分配在托管堆上,然后就不用再管。当一个对象从代码库的任何部分都不可达是,垃圾回收器会删除它。但不一定是在函数返回后立即回收。

        2:CIL的new指令
            在IL代码中是newobj,它执行时步骤如下:计算分配对象所需要的总内存数,如果托管堆中有足够空间,就调用构造函数分配,它的地址恰好是下一个对象指针的上一个位置,在将引用返回之前,移动下一个对象的指针。如果不够则进行垃圾回收。
            法则:如果托管堆没有足够的内存分配所请求的对象,就会进行垃圾回收。
            垃圾回收时会挂起当前进程的所有线程,以保证他们在回收时不会访问堆。

    三:应用程序根的作用
        根就是一个存储位置,其中保存着对堆上一个对象的引用。垃圾回收时,没有根的对象认为是不可达的,CLR对建立“对象图”来判断。
        实际上,垃圾回收器使用了两个不同堆,一个专门用来存储非常大的对象,这个堆在回收周期中很少顾及。

    四:对象的代
        1:一般分为三代,从0开始。分代的目的基于以下看法:对象在堆中存在的时间越长,它越应该被保留。一般先从第0代进行垃圾收集,需要时再向上代收集。
        2:System.GC。强制回收一般发生在:应用程序将要进入一段代码,后者不希望被可能的垃圾回收中断;应用程序刚刚分配非常多的对象,想尽可能的删除已请求的内存。
            调用Collect()后应该总是调用WaitForPendingFinalizers()。Collect()可以带参数,表示第几代。即使显式垃圾回收一次,CLR在幕后也执行了多次。

    五:构建可终结对象
        1:System.Object定义的Finalize()虚方法默认什么都不做。重写的Finalize()是由垃圾回收器调用的,或者当APPDomain从内存卸载时被调用。
            重写Finalize()的唯一原因是:C#类使用了PInvoke或复杂的COM互操作性人物使用了非托管的资源。
            注意不能在结构类型上重写Finalize(),因为它是值类型。
        2:重写Finalize()
            不能使用override关键字,而应该使用类似析构函数的方式。因为C#编译器会在il代码中自动加上try语句,try语句中方的是你自定义的finalize要执行的操作,而finally语句里是它自动生成的一些错误检测代码,里面有执行基类的Finalize()。如果要用override关键字,就有了两个Finalize()函数。
        3:终结过程的细节
            一般只有在使用了非托管实体的类型时才重定义Finalize(),托管的自己会终结,没有意义再定义,并且终结时要花费时间的。
            在托管堆分配对象时,如果有自定义的Finalize方法,对象被标记为可终结的,同时一个指向该对象的指针被保存在“终结队列”里,“终结队列”是一个垃圾回收器维护的表,指向每一个在从堆上删除之前必须被终结的对象。当垃圾回收器确定到了从内存中释放一个对象的时间时,它检查终结队列上的每一项,并将对象从堆上复制到另一个“终结可达表”的托管结构上,下一个垃圾回收时产生另一个线程,为每一个可达表中的对象调用Finalize方法。因此,终结一个对象,至少要进行两次垃圾回收。

    六:构建可处置对象
        1:结构和类类型都支持IDispoable,而Fianlize只适用于类类型。
        2:Dispose必须要被手工调用。Dispose()方法不但负责释放一个对象的非托管资源,还应该对任何它包含的可处置对象调用Dispose()。
        3:法则:如果对象支持IDispoable,总是要对直接创建的对象调用Dispose()。
        4:重用C#的using关键字,可以减少使用try,finally语句块。

    七:构建可终结类型和可处置类型
        1:Dispose如果处理了非托管资源,应该调用GC.SuppressFinalize方法,通知CLR不再调用析构函数。
        2:微软有一个可处置模式的模板,可以让Finalize()和Dispose()和平相处。
    展开全文
  • java 面试题 总结

    2009-09-16 08:45:34
    Java Bean 是可复用组件,对Java Bean并没有严格规范,理论上讲,任何一个Java类都可以是一个Bean。但通常情况下,由于Java Bean是被容器所创建(如Tomcat),所以Java Bean应具有一个无参构造器,另外,...
  • 从线性表的第一个元素开始,依次将线性表中的元素与被查找的元素相比较,若相等则表示查找成功;若线性表中所有的元素都与被查找元素进行了比较但都不相等,则表示查找失败。 例如,在一维数组[21,46,24,99,57,...
  • c语言编写单片机技巧

    2009-04-19 12:15:17
    而汇编语言,一条指令就对应一个机器码,每一步执行什幺动作都很清楚,并且程序大小和堆栈调用情况都容易控制,调试起来也比较方便。所以在单片机开发中,我们还是建议采用汇编语言比较好。 如果对单片机C语言有...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    C#--微软.NET的第一语言 本书着重介绍语言本身,比较少涉及应用,不错的入门书,从头讲起,不怕不明白。 <<page 1>> page begin==================== 目 目目 目 录 录录 录 第一部分 C#语言概述.4 ...
  • C#微软培训资料

    2014-01-22 14:10:17
    第三章 编写第一个应用程序 .20 3.1 Welcome 程序 .20 3.2 代 码 分 析 .20 3.3 运 行 程 序 .23 .4 添 加 注 释 .25 3.5 小 结 .27 第二部分 C#程序设计基础.28 第四章 数 据 类 型 .28 4.1 值 类 型...
  • 2004-2010软考程序员真题

    热门讨论 2012-09-27 12:33:00
     A)将两次插入内容全部取消 B)将第一次插入内容全部取消  C)将第二次插入内容全部取消 D)两次插入内容都不被取消  59、下列属于微机网络所特有设备是  A)显示器 B)UPS电源 C)服务器 D)鼠标器  ...
  • 第一个Student表示这是用Student类进行定义。“Student()”表示调用一个无参数构造方法。 如果()中有参数,则系统构造对象过程中调用有参方法。 此时S称为一个对象变量。 Student s存储区域存放是地址:...
  • (15) 在软件生命周期中,能准确地确定软件系统必须做什么和必须具备哪些功能阶段是(D) 注:即第一个阶段 A. 概要设计 B. 详细设计 C. 可行性分析 D. 需求分析 (16) 数据流图用于抽象描述一个软件逻辑模型,数据...
  • 这里的IDE设备包括了IDE硬盘和IDE光驱,第一、第二组设备是指主板上的第一、第二根IDE数据线,一般来说靠近芯片的是第一组IDE设备,而主设备、从设备是指在一条IDE数据线上接的两设备,大家知道每根数据线上可以接...
  • VB课程设计俄罗斯方块

    热门讨论 2011-02-25 10:46:55
    才能由横着变成竖立状态,游戏区图形框中第三行的第一个方块的编号为20,所以长条造型的第一个小方块的编号n(0)必须要大于20。同样,长条型方块在下落到底部的时候也有限制。如果长条下落到最后一行也将无法由横着...
  • ava本身是一个开发平台,开发后Java程序也是运行在Java平台上。也就是说, 开发后Java程序也是部署在Java平台上,这个尤其在后面学习JEE(Java企业版) 时候,体现更为明显 :Java能干什么 JaⅦa能做事情很...
  • Visual C++ 2008入门经典--详细书签版

    热门讨论 2013-02-02 16:07:15
     本书系编程语言先驱者ivor horton经典之作,是c++编程方面最畅销图书品种之,不仅涵盖了visual c++ 2008编程知识,还全面介绍了标准c++语言和c++/cli。本书延续了ivor horton讲解编程语言独特方法,从中...
  •  本书系编程语言先驱者ivor horton经典之作,是c++编程方面最畅销图书品种之,不仅涵盖了visual c++ 2008编程知识,还全面介绍了标准c++语言和c++/cli。本书延续了ivor horton讲解编程语言独特方法,从中...
  • 软件测试规范

    2018-04-23 09:16:12
    .概述 ............................................................................................................................................................ 1 二 软件测试理论 ....................
  • 36.6.1 第一个版本 272 36.6.2 固定字体大小 277 36.6.3 固定大小图标 278 36.6.4 使用空间 278 36.6.5 不是浏览器会怎样 279 36.7 合作伙伴错误有哪些 280 第37章 手机处理 281 37.1 该应用...
  • 千里马酒店前台管理系统V7使用手册

    热门讨论 2011-06-16 14:09:38
    按酒店前台业务部门分组,千里马V7.2功能划分为可自定义的一个个动态工作视图,即房态视图、预订视图、接待视图、收银视图、管家视图、夜核视图、问讯视图、礼宾视图、报表视图等。这些工作视图以及相关操作、...
  • 第一个试点项目是公司内部组件库(另有<a href="https://github.com/kuitos/angular-es6-seed">seed项目)。目前已经实施了三个多月,期间也包括一些其它新开产品试点。中间也经历一些痛苦及反复(组件库...
  • 4、观察并记录一个正常呼叫全过程。 5、观察并记录一个不正常呼叫状态。 图1-6 呼叫识别电路框图 五、 实验步骤 1、接上交流电源线。 2、将K11~K14,K21~K24,K31~K34,K41~K44接2,3脚;K70~K75接2,3脚...
  • 下面这张图生动呈现了一个 Bit 组件构成要素。 <p><img alt="Bit-component.png" src="https://i.loli.net/2020/09/27/ZbDHx81nKIJGzQj.png" /></p> <h3>Bit 组件生命周期 <p>Bit 组件发布和使用都是通过...
  • 可放在程序运行的第一个函数 被调试返回真 .子程序 AntiODMenu, 逻辑型, 公开, 这个效果较好,推荐用这个;找到OD相关句柄返回真, 此函数枚举窗口通过菜单名来 判定是否OD窗口。 .子程序 AntiStrongOD, 逻辑型, ...
  • 修改高级表格支持库,在双击单元格进入编辑状态后,不能收到第一个“字符输入”事件BUG。 2. OpenGL支持库中部分英文名称常量已改为中文,并统一在所有常量名称之前加前缀“GL_”,以减少与其它库冲突机率。...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

任何指令的第一个周期一定是