优行网络笔试题目

简要叙述arrraylist,vector，linkedlist 的存储性能和特性

ArrayList 和 vector 都是使用数组的方式存储数据，此数据大于实际存储的数据以便增加和删除元素，他们都允许直接按照序号索引元素，但是插入元素要涉及元素移动的内存操作，所以索引数据块，而插入数据慢。

Vector 使用synchoronize方法线程安全，通常性能叫arrayList 差，而

likedList使用双向链表存储，按照序号索引数据需要进行前序活后巷遍历，但是插入数据只需要记录本想的前后想之和。所以插入速度较快。

 

 

Hashmap 和hashTable的区别

1.继承的类层次不一样，一个hashMap 继承map,hashTable 继承dictory类。

6.线程安全性

7.遍历方式不同：

Hashtable,hashMap都使用了iterator，由于历史原因，hashtable还使用了Enumberation的方式。

  hashMap 的iterator 是fail-fast 迭代期，当有其他线程改变了hashMap的结构，

（增加，删除，修改元素），将会抛出concurentModification Exception.

   不过，通过iterator的remove()方法移除元素则不会抛出concurrntModificationexception异常。

Jdk 8之前的版本中，hashtabe是没有fast-fail机制的。在jdk8 以及以后的版本中，hashTable 也是fast-fail 的，源码

 

8.初始化容量大小和每次库充荣来那个的大小的不同

Hashtable 默认的初始化大小是11,之后每次扩充，容量变为原来的2n+1,

hashMap默认的初始化的大小是16.之后每次扩充的，容量变为原来的2被。

 

创建时，如果给定了容量的初始化数值，那么hashtable,那么hashTable 会直接的使用你给定的大小，而hashMap 会将其扩充2的米次方大小。

也就说hashtable 会是要弄个使用素数，气说。

而hashmap 则总是会使用2的明作为何时表的大小。

 

之所以会有这样的，是因为hashtable和hashMap设计时的侧重点不通，

Hashtable的侧重点是哈市结果更加均匀，是的hash冲突减少。

当哈市表的小说为诉说是，简单的驱魔哈市，会更加的均匀。

 

9.计算hash 数值的方法不同

为了得到一个元素的位置，首先会根据元素的key ,计算出一个hash

然后在用hash数值，计算最终得到的位置。

Hashtable直接使用对应的hashCode。hashCode是jdk根据对象的地址或者字符串计算出来的数值，然后在使用的初六的约束来活的最终的位置。

 Int  hash=key=hashCode();

Int index=(hash &0x7fffff);

Hashtable 在计算的元素的位置需要进行一次出发的元算，而出发运算是比较耗时间的。

Hashmap 是为了提高计算效率，将哈希表的大小固定的为了2的闽南歌。这样在取模的只做出发元算，只需要做委员孙。

Hashmap 的效率虽然提高了，但是hash冲突也增加了。因为他得出的hash

数值，低位相同的概率比较高。

 

       为了解决这个问题，hashMap 重新根据hashCode 计算hash数值后。

 Static final int   hash(Object key){

  Int h;

Return (key==null)? 0：(h=key.hashCode());

}

 

 

 

 

 

 

 

 

 

写一个singletong出来

public class Single {

 

    private static Singleton instance=new Single();

 

    private Singletom() {}  //私有默认的构造

   

    public static Single getInstance() {

        return instance;

    }

}

 

简述synchrozied,和java.util.concurent.locks,lock 的异同:

1. Lock能完成几乎所有synchronized 的工作，并有一些或者不具备的功能如

所投片，定时锁等候，可中断锁等。

1. synchronized 是java 语言层面的，是内置的关键字，Lock是jdk 中

出现的一个包，在使用时，synroind同步的代码块可以有

Jvm 自动释放。Lock 需要程序员在finally 块中手工释放，如果

不释放可能会引起不可许燎的后果。

 

1. 排序方法都有那几种？用java 实现一个快速排序方法。

快速排序方法：

 

用最有效率的方式计算2*17等于多少？

0000 0010 =>左移动4位 0001 0000=16

2*17 = 2* ( 2^4 + 1 )

= 2^5 + 2 = 2<<4 +2

0000 0010

0001 0000

向左移动4位加2.

试着简要叙述一下对Java多线程中“锁“”概念的理解。

 

分类： 公平所的

公平所的是指多个线程暗号申请的锁的苏圩来获取锁。

非公平锁的是指多个线程获取的锁的顺序，并不是按照申请的锁的顺序，有可能

申请的线程比先申请的线程优先获取锁。

有可能，

 

非公平锁的是之多个线程暗中啊申请锁的顺序。

对于java RecentrantLock 而言，通过构造函数制定该所是不是公平所，默认是非公平锁。非公平所的优点在于吞吐量比公平所的大。

对于synchroized 而言，也是一种非公平所。由于其不想RentrantLock是通过AQS来实现线程调度的，所以并灭有任何方法使其编程公平所。

 

可重入锁

可重入锁，

有名递归所，是真在同一个线程中在外层方法获取锁的时候，在进入内层方法会自动获取所。对于Java RenetrenatLock 而言，名字是reenttrantLock即使重新禁入所，对于syniced而言，是一个可重入锁。可重入锁的好处在一定程度上避免死锁。

Synchroned void seta()  throws Exception{

   Thread.sleep(1000);

  setB();

}

 

Synchronized void setB() throws exception{

    Thread.sleep(1000);

}

上面的代码就是一个可重入的锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造死锁。

 

 独享所和共享所

独享所是指在该所的一次只能被一个线程锁持有，共享所是指可能被多个线程持有。

对于Java recentreantLock而言，其是独享锁。

但是对于Lock的另一个实现了readwriteLOck 是，其堵锁是共享所，其些所是独享多。都铎的共享可保证并发度是非常高效的，读写，写读，谢谢的过程是互斥的。

独享多的与共享所也是通过AQS来实现的。

 

乐观锁和悲观锁

乐观所与悲观所的并不是之具体类型的锁，而是之卡带难问题的角度。

悲观锁：总是假设最坏的情况，每次去哪数据都被认为是别人会修改，所以每次在拿数据的时候都上锁，这样别人想拿这个数据就会堵塞知道堵塞知道他拿到所。比如java 里面的同步源于synchroinized 关键字的实现就是悲观所。

乐观锁：

顾名思义，就是很乐观，每次拿去数据的时候，都认为别人不会修改，所以不会上锁，但是更新的时候会判断一下再次期间别人有没有更新这个数据，乐观锁

适合多读的应用类型，这样就可以提高多读的应用类型，这样可以提高兔兔辆

在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 比较并交换)实现的。

 

 

1. AQS的

抽象的队列同步器，AQs

 

 

 

1. 所有的递归实现是否可以用循环的方式实现？请描述一下这两种实现方式各自的优劣。举例说明在什么情况下使用递归，而在什么情况下只能循环而不能使用递归。

 

 

1. RE 递归算法：

优点：代码简洁、清晰，并且容易验证正确性

缺点：它的运行需要较多次数的函数调用，如果调用层数比较深，需要增加额外的堆栈处理（还有可能出现堆栈溢出的情况），比如参数传递需要压栈等操作，会对执行效率有一定影响。但是，对于某些问题，如果不使用递归，那将是极端难看的代码。

循环算法： 优点：速度快，结构简单。 缺点：并不能解决所有的问题。有的问题适合使用递归而不是循环。如果使用循环并不困难的 ...

下面的代码在绝大部分时间内运行的很正常，请问在什么情况下会出现问题，问题的根源在那里？

Import java.util.linkedList;

Public  class Stack{

LinkedList list=new LinkedList();

Public synchroznized void push(){

Synchrozized(list){

  List.addLast(x);

Notify();

}

}

 

Public synrozied void pop(){

      Synchied(this){

     If(list.size()<=0){

Wait();
}

}

Return list.removelast();

}

1. 验证4个线程，其中两个线程，对于j增加1，另外2个线程对j每次减少1，写出程序。
2. private int j=0;
3.  
4. public synchronized void inc() {
5.      j++;
6.  System.out.println(Thread.currentThread().getName()+"inc"+j);
7. }
8.  
9. public synchronized void dec() {
10.      j--;
11.      System.out.println(Thread.currentThread().getName()+"dec"+j);
12. }
13.  

 

private Manythread many=new Manythread();

   

    public static void main(String[] args) {

        MyTest myTest=new MyTest();

        myTest.test();

    }

 

    private void test() {

        // TODO Auto-generated method stub

       

    for(int i=0;i<2;i++) {

       

        new Thread(

                 new Runnable() {

                    public void run() {

                       

                        for (int j = 0; j < 20; j++) {

                            many.inc();

                        }

                    }

                }

               

               

                ).start();

       

       

         new Thread(

                   new Runnable() {

                    public void run() {

                     

                        for (int j = 0; j < 20; j++) {

                            many.dec();

                        }

                    }

                }

                 

                 ).start();

       

    }