2020-11-11

1. 以下哪个不能用来处理线程安全 D

A synchronized关键字

B volatile关键字

C Lock类

D transient关键字

A synchrozied关键字称作同步，主要用来给方法、代码块加锁，被加锁的代码段，同一时间内多线程同时访问同一对象的加锁方法/代码块时，只能有一个线程执行能执行方法/代码块中的代码，其余线程必须等待当前线程执行完以后才执行该方法/代码块。

B volatile关键字1.保证了不同线程对该变量操作的内存可见性.(当一个线程修改了变量,其他使用次变量的线程可以立即知道这一修改)。2.禁止了指令重排序.

C Lock接口提供了与synchronized关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。

D transient关键字  简单地说，就是让某些被修饰的成员属性变量不被序列化。

2. 下列程序执行后输出结果为（      ） D

class BaseClass {  
    public BaseClass() {}  {  
        System.out.println("I’m BaseClass class");  
    }  static {  
            System.out.println("static BaseClass");  }     
    }  public class Base extends BaseClass {  
        public Base() {}  {  
            System.out.println("I’m Base class");  }  
        static {  System.out.println("static Base");  }  
        public static void main(String[] args) {  new Base(); 
    }
}  

A static BaseClass

I’m BaseClass class

static Base

I’m Base class

 

B I’m BaseClass class

I’m Base class

static BaseClass

static Base

 

C I’m BaseClass class

static BaseClass

I’m Base class

static Base

 

D static BaseClass

static Base

I’m BaseClass class

I’m Base class

补充一下完整版的，执行顺序从左到右：

    父类静态代码块 ->子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。

案例代码如下：

public class Father {  static {
        System.out.println("父类静态代码块");    }

    {
        System.out.println("父类非静态代码块");    }  public Father(){
        System.out.println("父类构造函数");    }   }
public class Son extends Father{  static {
        System.out.println("子类静态代码块");    }

    {
        System.out.println("子类非静态代码块");    }  public Son(){
        System.out.println("子类构造函数");    }  public static void main(String[] args) {
        Son son = new Son();    }
}

结果为： 父类静态代码块 子类静态代码块 父类非静态代码块 父类构造函数 子类非静态代码块 子类构造函数

3. 下列说法正确的是( ) C

A volatile,synchronized 都可以修改变量，方法以及代码块

B volatile，synchronized 在多线程中都会存在阻塞问题

C volatile 能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

D volatile 解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且只能修改变量，而synchronized可以修饰方法，以及代码块。

多线程访问volatile不会发生阻塞，而synchronized会出现阻塞.

volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步

关键字volatile解决的下变量在多线程之间的可见性；而synchronized解决的是多线程之间资源同步问题

4. 下列代码编译和运行的结果是：（）  C

public class Threads4{  public static void main(String[] args){  new Threads4().go();  }  public void go(){  Runnable r=new Runnable(){  public void run(){  System.out.print("foo");  }  };  Thread t=new Thread(r);  t.start();  }  }

A 编译错误

B 抛出运行时异常

C 输出：foo

D 代码正常运行，但是无输出

5. 某程序要求每次输入只能是正整数，并且每次输入的数值要求必须是100的倍数且小于等于500，则下列哪个是正确的无效等价类(        ) C

A （0，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

B （500，+∞）

C （500，+∞）、任意大于0小于500的非100倍数的整数；

D （-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

无效等价类是指对于软件规格说明而言，是没有意义的、不合理的输入数据集合。利用无效等价类可以找出程序异常说明情况，检查程序的功能和性能的实现是否有不符合规格说明要求的地方。

有效等价类是指输入数据完全满足程序输入的规格说明，是有效、有意义的输入数据所构成的集合。利用有效等价类可以检验程序是否满足规格说明所规定的功能和性能。 

应该选 C，因为C的后面一句话是已经排除了负数中的100的整数倍了

6. 关于多线程和多进程，下面描述正确的是（）AC

A 多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。

B 线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。

C 线程的通信速度更快，切换更快，因为他们在同一地址空间内。

D 一个线程可以属于多个进程。

A.子进程得到的是除了代码段是与父进程共享以外，其他所有的都是得到父进程的一个副本，子进程的所有资源都继承父进程，得到父进程资源的副本，子进程可获得父进程的所有堆和栈的数据，但二者并不共享地址空间。两个是单独的进程，继承了以后二者就没有什么关联了，子进程单独运行；进程的线程之间共享由进程获得的资源，但线程拥有属于自己的一小部分资源，就是栈空间，保存其运行状态和局部自动变量的。

B.线程之间共享进程获得的数据资源，所以开销小，但不利于资源的管理和保护；而进程执行开销大，但是能够很好的进行资源管理和保护。

C.线程的通信速度更快，切换更快，因为他们共享同一进程的地址空间。

D.一个进程可以有多个线程，线程是进程的一个实体，是CPU调度的基本单位。

7. 在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？ BC

A 11

B 144

C 55

D 89

你需要爬11楼的时候，你倒回去一步只能待在第10楼或者第9楼。换句话说就是到达第9楼的方法次数加上第10楼的方法次数。

如果你待在第10楼，就得待在第9楼或者第8楼

如果你待在第9楼，就得待在第8楼或者第7楼

......

如果你待在第3楼，就得待在第1楼或者第2楼

爬1楼一种方法，

爬2楼两种方法。

爬3楼就是爬1楼方法次数加2楼的方法次数。

用数学表达就是：

a（11）=a（10）+a（9）=144

a（10）=a（9）+a（8）=89

a（9）=a（8）+a（7）=55

a（8）=a（7）+a（6）=34

a（7）=a（6）+a（5）=21

a（6）=a（5）+a（4）=13

a（5）=a（4）+a（3）=8

a（4）=a（3）+a（2）=5

a（3）=a（2）+a（1）=3

a（2）=2

a（1）=1

8. 下列那些方法是线程安全的(所调用的方法都存在) ACD

A public class MyServlet implements Servlet { public void service (ServletRequest req, ServletResponse resp) { BigInteger I = extractFromRequest(req); encodeIntoResponse(resp,factors); } }

B public class MyServlet implements Servlet { private long count =0; public long getCount() { return count; } public void service (ServletRequest req, ServletResponse resp) { BigInteger I = extractFromRequest(req); BigInteger[] factors = factor(i); count ++; encodeIntoResponse(resp,factors); } }

C public class MyClass { private int value; public synchronized int get() { return value; } public synchronized void set (int value) { this.value = value; } }

D public class Factorizer implements Servlet { private volatile MyCache cache = new MyCache(null,null); public void service(ServletRequest req, ServletResponse resp) { BigInteger i = extractFromRequest(req); BigInteger[] factors = cache.getFactors(i); if (factors == null) { factors = factor(i); cache = new MyCache(i,factors); } encodeIntoResponse(resp,factors); }