面试经历---Samp；G（2016年02月27日上午面试）

S&G是一家外企，在广州琶州那边，下面附上这家企业的笔试题。

2016年2月27日上午笔试题

一． JAVA基础题

1. 什么是接口？

接口就是一些方法特征的集合，是对对象的抽象。

2. 什么时候使用抽象类来替代接口？

存在继承关系的情况下，可以使用抽象类来替代接口。

3. 什么是final关键字？什么时候能用它？

（1）使用final修饰的类不可以被继承

（2）使用final修饰的方法不可以被重写

（3）使用final修饰的变量不可以被重新赋值

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但被引用对象的内容是可以改变的。

4. 如果有一个final collection，比如final List，给它填充数据，那么list里面的值可以改变吗？

List不可以指向其他对象，但list里面的值是可以改变的。

5. 为什么说声明一个final class是一个好的做法？

防止类被继承。

6. 什么是不可变和可变的类？

（1）可变类

当你获得一个类的实例引用时，你可以改变这个实例的内容。

（2）不可变类

当你获得一个类的实例引用时，你不可以改变实例中的内容。

不可变类的实例一旦创建，其内在成员变量的值就不能被修改。

创建一个不可变类：所以成员都是private，不提供对成员的改变方法，确保所有的方法不会被重载，比如类加上修饰符final(强不可变类)，或者所有类方法加上final（弱不可变类）。

7. 将一个对象传入一个方法，那些引用是传参引用还是传值引用？

传值引用。

函数参数的传递分为两种：“值传递”和“引用传递”.

“值传递”—传递原参数的拷贝, 基本数据类型参数，都是值传递；函数内部修改此参数，则原数据不变.

“引用传递”—传递原参数本身, 对象参数，则为引用传递；函数内部修改此参数，则原对象更改.

注意：JAVA中函数参数的传递为值传递。参数为对象时，传递的是原参数引用的拷贝，这个引用的拷贝同样会指向原对象。因此，在函数中对对象参数的修改，能够体现到原对象。

1.对象就是传引用

2.原始类型就是传值

3.String，Integer, Double等immutable类型因为没有提供自身修改的函数，每次操作都是新生成一个对象，所以要特殊对待。可以认为是传值。

Integer 和 String 一样。保存value的类变量是Final属性，无法被修改，只能被重新赋值／生成新的对象。当Integer 做为方法参数传递进方法内时，对其的赋值都会导致原Integer 的引用被指向了方法内的栈地址，失去了对原类变量地址的指向。对赋值后的Integer对象做得任何操作，都不会影响原来对象。

传值

如果是基本数据类型，则传递的是值

如果是对象，则传递的是对象引用的副本，如果只是在方法中修改这个对象的值，则会影响外部的对象；如果修改了引用的指向，则不会影响外部的对象。

public class MyObject {private String name;public MyObject(Stringname){this.setName(name);}public String getName() {returnname;}public void setName(String name) {this.name =name;}
}import java.util.ArrayList;
import java.util.List;public class Test2 {public int i = 0;public void doSomething1(intn){n = 2;}public void doSomething2(String value){value = "name2";}public void doSomething3(List<String> list){if(list ==null){list = new ArrayList<String>();}list.add("value1");}public void doSomething4(MyObject myObject) {myObject.setName("name2");}public void doSomething5(MyObject myObject) {myObject = new MyObject("name3");}public static void main(String args[]) {Test2 test = new Test2();int n = 1;String value = "name";List<String> list = new ArrayList<String>();list.add("test");MyObject myObject = new MyObject("name1");MyObject myObject2 = new MyObject("name2");test.doSomething1(n);test.doSomething2(value);test.doSomething3(list);test.doSomething4(myObject);test.doSomething5(myObject2);System.out.println("n="+n);System.out.println("value="+value);System.out.println("list="+list.toString());System.out.println("myObject name="+myObject.getName());System.out.println("myObject2 name="+myObject2.getName());}}

输出的结果是

n=1

value=name

list=[test, value1]

myObject name=name2

myObject2 name=name2

二． JVM和内存

1. 一般垃圾回收器包含哪些空间？

所有的回收器类型都是基于分代技术。Java HotSpot虚拟机包含三代，年轻代(Young Generation)、年老代(Old Generation)、永久代(Permanent Generation)。

永久代

存储类、方法以及它们的描述信息。可以通过-XX:PermSize=64m和-XX:MaxPermSize=128m两个可选项指定初始大小和最大值。通常我们不需要调节该参数，默认的永久代大小足够了，不过如果加载的类非常多，不够用了，调节最大值即可。

年老代

主要存储年轻代中经过多个回收周期仍然存活从而升级的对象，当然对于一些大的内存分配，可能也直接分配到永久代(一个极端的例子是年轻代根本就存不下)。

年轻代

绝大多数的内存分配回收动作都发生在年轻代。如下图所示, 年轻代被划分为三个区域，原始区(Eden)和两个小的存活区(Survivor)，两个存活区按功能分为From和To。绝大多数的对象都在原始区分配，超过一个垃圾回收操作仍然存活的对象放到存活区。

2. 一般垃圾回收器中堆空间和永久代空间的区别是什么？

（1）堆用来保存实例和数组，所有的线程共享这一区域

（2）永久代空间用来保存类、方法以及它们的描述信息

JVM内存结构：方法区+堆+栈+本地方法栈

垃圾回收空间划分：年轻代+年老代+永久代

年轻代+年老代=堆

永久代=方法区

3. 垃圾回收器中的永久代空间能被回收吗？

永久代的垃圾回收和老年代的垃圾回收是绑定的，一旦其中一个区域被占满，这两个区都要进行垃圾回收。但是有一个明显的问题，由于我们可以通过‑XX:MaxPermSize 设置永久代的大小，一旦类的元数据超过了设定的大小，程序就会耗尽内存，并出现内存溢出错误(OOM)。

备注：在JDK7之前的HotSpot虚拟机中，纳入字符串常量池的字符串被存储在永久代中，因此导致了一系列的性能问题和内存溢出错误。

着Java8的到来，我们再也见不到永久代了。但是这并不意味着类的元数据信息也消失了。这些数据被移到了一个与堆不相连的本地内存区域，这个区域就是我们要提到的元空间。

4. 永久代是怎么样才会出现内存溢出？

永久代主要存放类、方法及其描述信息，但这些成员的大小超过设定的MaxPermSize时，就会出现内存溢出。

也可能通过CGLIB动态生成类，这样也可能会出现内存溢出。

5. 一个对象在什么情况下才会被垃圾回收器回收？

垃圾回收器每隔一段时间或者达到一定的阀值，就会执行回收操作，如果对象没被引用时，就会被垃圾回收器回收。

确定对象是垃圾

（1）引用计数器算法，JDK1.1后这个算法淘汰

（2）根搜索算法

根搜索方法是通过一些“GC Roots”对象作为起点，从这些节点开始往下搜索，搜索通过的路径成为引用链（Reference Chain），当一个对象没有被GC Roots的引用链连接的时候，说明这个对象是不可用的。

GC Roots对象包括：

a) 虚拟机栈（栈帧中的本地变量表）中的引用的对象。

b) 方法区域中的类静态属性引用的对象。

c) 方法区域中常量引用的对象。

d) 本地方法栈中JNI（Native方法）的引用的对象。

垃圾回收算法

（1）标记-清除算法

（2）复制算法

（3）标记整理算法

（4）分代收集

新生代---标记清除算法

老年代—整理算法

6. 什么是弱引用？

http://zhangjunhd.blog.51cto.com/113473/53092/

⑴强引用（StrongReference）

强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

⑵软引用（SoftReference）

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存（下文给出示例）。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

⑶弱引用（WeakReference）

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

⑷虚引用（PhantomReference）

“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

ReferenceQueue queue = new ReferenceQueue ();

PhantomReference pr = new PhantomReference (object, queue);

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

三． JAVA语言

1. String、StringBuilder、SringBuffer的区别是什么？

String是不可变对象

StringBuilder和StringBuffer都是可变对象，StingBuilder是线程不安全的，但效率较高；StringBuffer是线程安全的，但效率较低。

2. new String(“abc”)和”abc”的区别是什么？

“abc”只创建一个字符串对象

new String(“abc”)是创建两个字符串对象

3. 使用doubles来描述价格的陷阱是什么？

四． JAVA集合

1. ArrayList和LinkedList的区别是什么？什么条件下会选择谁？

ArrayList的内部存储是使用数组，查询的效率较高，修改和删除的效率较低。

LinkedList的内部存储是使用链表，查询的效率较低，修改和删除的效率较高。

2. Hashcode和equals 方法的区别是什么

每个对象都有一个hashcode，但并不唯一，不同对象的hashcode可能相同。

Equals方法通常是比较两个对象是否相等，可以使用==号来比较两个对象的内存地址是否相等，也可以通过比较两个对象的hashcode是判断是否相等。

3. HashMap和ConcurrentHashMap的区别是什么？

HashMap不是线程安全的

ConcurrentHashMap加了ReentrantLock锁，是线程安全的。

4. ConcurrentHashMap是如何工作的？

内部存储使用数组+链表，对象根据他们的hashcode对数组的大小取余数来获得数组的位置；如果不同的对象有相同的hashcode，则这些对象存放在一个链表中，查询时通过hashcode获取数组的位置，再通过==判断对象的内存地址是否相同来获取对象。加了ReentrantLock锁

5. 如果HashMap中出现了冲突怎么办？

冲突的键放在一个链表中。

如果是JDK1.8，链表长度大于8，则把链表转换成红黑树。

6. 如果HashMap中存在大量的冲突，怎么办？

如果是JDK1.8，链表长度大于8，则把链表转换成红黑树。

7. Map、Set、List的区别是什么？

Map是键值对

Set是不重复的集合

List是一个数组集合

Set和List都继承自Collection

五． JAVA线程

1. 有哪些常用方法来防止出现死锁？

(1)有序的资源分配法，
(2)银行家算法。

2. 解释一下synchronized关键字？

Synchronized是给一个对象、方法或代码块加上锁，如果资源已经被其他线程锁住了，则会一直等待，直到其他线程释放资源。

monitor enter

monitor exit

RetanrantLock是非阻塞锁，Synchronized是阻塞锁。

AQS+CAS

3. 什么是volatile关键字？

JAVA内存模型中包括主内存（方法区）和工作内存（栈），变量的值通常放在主内存中，而线程在调用这一共享变量时，是拷贝一份到自己的工作内存中，线程对自己工作内存中的变量进行读写，写完后再同步到主内存中。如果变量使用了volatile关键字，可以确保线程对工作内存中的变量进行修改后，会及时同步到主内存，并且同步到其他线程的工作内存中，保存线程对变量修改的可见性。Volatile是通过禁止编译的的指令重排序来实现这一功能的。但volatile这一关键字并不能保证多线程对同一变量同时修改的原子性。

4. 当然调用了一个synchronized static method时，我是锁住了对象实例还是类对象？

锁住了类对象。

5. 如何创建一个线程的？

继承类Thread，或者实现接口Runnable.

6. Thread.sleep()和Thread.wait()的区别？

Sleep在睡眠一定的时间后，线程会自己醒来，沉睡的过程中占用CPU.

Wait需要需要其他线程来唤醒才会醒来，自己不会醒来，沉睡的过程中不占用CPU.

六． JAVA模式

1. 选择一种模式并且描述他是如何工作的（观察者模式、策略模式、外观模式、装饰模式、访问者模式）

1.1 观察者模式Observer

定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象。这个主题对象在状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自己。

应用场景：当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。

1.2 策略模式Strategy

定义了算法家庭，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。

应用场景：经常需要改变计算方式的情况。

1.3 外观模式Facade

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层的接口，这个接口使得这一子系统更加容易使用。

比如买股票和买基金，如果是买股票，则需要亲力亲为去买每一只股票，如果是买基金，只要购买基金则可，基金中包含了哪些股票则不需要关心。

常用的MVC模式就是使用外观模式，当一个请求需要同时访问多个多个service时，可以定义一个Controller接口，在这个接口中调用多个service服务。

1.4 装饰模式Decorator

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

1.5 访问者模式

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

七．其他问题

1. 什么是IOC？

控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。一个对象所依赖的对象的引用，不是在对象中直接定义，而是通过容器来注入，降低对象之间的耦合度。

调用类只依赖接口，而不依赖具体的实现类，减少了耦合。控制权交给了容器，在运行的时候才由容器决定将具体的实现动态的“注入”到调用类的对象中。

2. 解释一下依赖注入？

依赖注入(DependencyInjection)是控制反转的一种实现方法。JamesShore给出了依赖注入的定义：依赖注入就是将实例变量传入到一个对象中去。

AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

八． Spring

1. Spring中下面的注解用来做啥的？

a. Autowired

自动装载属性值，不需要在对象中设定属性的值，而是由容器自动去装载。

b. Transactional

自动装载事务

c. Bean

将一个对象添加到Spring容器中。

d. Component/Service/Repository

@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@Service用于标注业务层组件

@Repository用于标注数据访问组件，即DAO组件

e. Controller

@Controller用于标注控制层组件

f. RequestMapping

@ RequestMapping用于标识访问地址

2. 列出Spring 3和 Spring 4的一些差异？

3. 给出一个简单的Web应用，你会如何做架构设计？

九． REST

1. REST中有哪些HTTP 方法？描述一下它们的作用

2. 解释一下HATEOAS（Hypermedia As The Engine Of Application State）

面试题

1.HashMap产生collision后，怎么办？

HashMap的存储结构是数组+链表，不同hashcode的KEY存放到数组中的不同位置，同一hashcode的KEY存放到数据组中的同一位置，但用链表保存。

查找某一KEY时，先取得KEY的hashcode，再通过hashcode计算出数组的位置，再取出该数组位置中的链表，然后遍历链表看哪一个键值与KEY的内存地址是一致的，

如果是一致，则视同是同一个KEY，并且取出该KEY对应的VALUE. 不同的KEY可以有相同的hashcode，但他们在内存中的地址一定是不同的。

2.如何解决deadlock

目前并没有能够很好解决deadlock的方法，常用的可以增加资源供给，使用单线程或排队，但在多线程并且资源有限的情况下，只能根据经验或通过分析JVM中的死锁来解决。

3.Spring Bean的scope

Singleton,prototype,request,session,global session

后三种只能在WEB应用中使用。

4.HashMap、HashTable、ConcurrentHashMap的区别？

HashMap的KEY和VALUE可以为空，但不是线程安全。

HashTable的KEY和VALUE不可以为空，但是线程安全，加了synchronized锁。

ConcurrentHashMap的KEYKEY和VALUE不可以为空，但是线程安全，加了分段锁ReentrantLock，默认16个段。

虽然都是线程安全的，但ConcurrentHashMap的效率要比HashTable高。

5. ReentrantLock与Synchronized的区别

（1）ReentrantLock 拥有Synchronized相同的并发性和内存语义，此外还多了锁投票，定时锁等候和中断锁等候

线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，
如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断
如果使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情

（2）ReentrantLock获取锁定与三种方式：
a) lock(), 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁
b) tryLock(), 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；
c)tryLock(long timeout,TimeUnit unit)，如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；
d) lockInterruptibly:如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断

（3）synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中

（4）在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态

（5）什么时候才应该使用 ReentrantLock
在确实需要一些 synchronized 所没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票。

6.如何分析程序中是否存在死锁？

下面写几个类来模拟死锁，分别是两个资源类ResourceA、ResourceB，以及两个线程MyThread1、MyThread2

public class ResourceA {private int count = 1;public int getCount() {return count;}public void setCount(int count) {this.count = count;}
}

public class ResourceB {private int count = 1;public int getCount() {return count;}public void setCount(int count) {this.count = count;}
}

public class MyThread1 implements Runnable {private ResourceA resourceA;private ResourceB resourceB;public MyThread1(ResourceA resourceA, ResourceB resourceB){this.resourceA = resourceA;this.resourceB = resourceB;}@Overridepublic void run() {System.out.println("thread1 ,wait to get lock from resourceA...");synchronized (resourceA) {System.out.println("thread1,already get lock from resourceA...");resourceA.setCount(resourceA.getCount() -1);try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread1,wait to get lock from resourceB...");synchronized (resourceB) {System.out.println("thread1,already get lock from resourceB...");resourceB.setCount(resourceB.getCount() -1);}System.out.println("thread1, already release lock from resourceB...");}System.out.println("thread1, already release lock from resourceA...");}}

public class MyThread2 implements Runnable {private ResourceA resourceA;private ResourceB resourceB;public MyThread2(ResourceA resourceA, ResourceB resourceB){this.resourceA = resourceA;this.resourceB = resourceB;}@Overridepublic void run() {System.out.println("thread2 ,wait to get lock from resourceB...");synchronized (resourceB) {System.out.println("thread2,already get lock from resourceB...");resourceB.setCount(resourceB.getCount() -1);try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread2 ,wait to get lock from resourceA...");synchronized (resourceA) {System.out.println("thread2,already get lock from resourceA...");resourceA.setCount(resourceA.getCount() -1);}System.out.println("thread2, already release lock from resourceA...");}System.out.println("thread2, already release lock from resourceB...");}}

public class TestDeadLock {public static void main(String[] args) {System.out.println("begin....");ResourceA resourceA = new ResourceA();ResourceB resourceB = new ResourceB();MyThread1 myThread1 = new MyThread1(resourceA, resourceB);MyThread2 myThread2 = new MyThread2(resourceA, resourceB);Thread thread1 = new Thread(myThread1);Thread thread2 = new Thread(myThread2);thread1.start();thread2.start();System.out.println("end....");}}

程序运行的结果是

begin....
thread1 ,wait to get lock from resourceA...
thread1,already get lock from resourceA...
end....
thread2 ,wait to get lock from resourceB...
thread2,already get lock from resourceB...
thread1,wait to get lock from resourceB...
thread2 ,wait to get lock from resourceA...

(1) 通过jps找到当前进程号

C:\Program Files\Java\jdk1.7.0_17\bin>jps
6284 TestDeadLock
7168 Jps
5628

可以发现TestDeadLock这个类的进程号是6284

(2) 通过jstack查看堆栈信息

查出进程号是6284的栈信息（线程保存在JVM的栈中）

C:\Program Files\Java\jdk1.7.0_17\bin>jstack -l 6284
2016-03-07 23:58:00
Full thread dump Java HotSpot(TM) Client VM (23.7-b01 mixed mode, sharing):"DestroyJavaVM" prio=6 tid=0x00879400 nid=0x774 waiting on condition [0x00000000
]java.lang.Thread.State: RUNNABLELocked ownable synchronizers:- None"Thread-1" prio=6 tid=0x02b57800 nid=0x1634 waiting for monitor entry [0x02fdf00
0]java.lang.Thread.State: BLOCKED (on object monitor)at com.MyThread2.run(MyThread2.java:27)- waiting to lock <0x22bf7fc0> (a com.ResourceA)- locked <0x22bf9080> (a com.ResourceB)at java.lang.Thread.run(Thread.java:722)Locked ownable synchronizers:- None"Thread-0" prio=6 tid=0x02b57400 nid=0x82c waiting for monitor entry [0x02f8f000
]java.lang.Thread.State: BLOCKED (on object monitor)at com.MyThread1.run(MyThread1.java:27)- waiting to lock <0x22bf9080> (a com.ResourceB)- locked <0x22bf7fc0> (a com.ResourceA)at java.lang.Thread.run(Thread.java:722)Locked ownable synchronizers:- None"Service Thread" daemon prio=6 tid=0x02b18c00 nid=0x1290 runnable [0x00000000]java.lang.Thread.State: RUNNABLELocked ownable synchronizers:- None"C1 CompilerThread0" daemon prio=10 tid=0x02b13000 nid=0x175c waiting on conditi
on [0x00000000]java.lang.Thread.State: RUNNABLELocked ownable synchronizers:- None"Attach Listener" daemon prio=10 tid=0x02b11400 nid=0x16d8 waiting on condition
[0x00000000]java.lang.Thread.State: RUNNABLELocked ownable synchronizers:- None"Signal Dispatcher" daemon prio=10 tid=0x02b0fc00 nid=0x1f44 runnable [0x0000000
0]java.lang.Thread.State: RUNNABLELocked ownable synchronizers:- None"Finalizer" daemon prio=8 tid=0x02af5000 nid=0x1f30 in Object.wait() [0x02daf000
]java.lang.Thread.State: WAITING (on object monitor)at java.lang.Object.wait(Native Method)- waiting on <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)- locked <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:177)Locked ownable synchronizers:- None"Reference Handler" daemon prio=10 tid=0x02af0400 nid=0x1b78 in Object.wait() [0
x02d5f000]java.lang.Thread.State: WAITING (on object monitor)at java.lang.Object.wait(Native Method)- waiting on <0x22b60da0> (a java.lang.ref.Reference$Lock)at java.lang.Object.wait(Object.java:503)at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)- locked <0x22b60da0> (a java.lang.ref.Reference$Lock)Locked ownable synchronizers:- None"VM Thread" prio=10 tid=0x02aee800 nid=0x1cf0 runnable"VM Periodic Task Thread" prio=10 tid=0x02b1c000 nid=0xc44 waiting on conditionJNI global references: 118Found one Java-level deadlock:
=============================
"Thread-1":waiting to lock monitor 0x02af4d24 (object 0x22bf7fc0, a com.ResourceA),which is held by "Thread-0"
"Thread-0":waiting to lock monitor 0x02af345c (object 0x22bf9080, a com.ResourceB),which is held by "Thread-1"Java stack information for the threads listed above:
===================================================
"Thread-1":at com.MyThread2.run(MyThread2.java:27)- waiting to lock <0x22bf7fc0> (a com.ResourceA)- locked <0x22bf9080> (a com.ResourceB)at java.lang.Thread.run(Thread.java:722)
"Thread-0":at com.MyThread1.run(MyThread1.java:27)- waiting to lock <0x22bf9080> (a com.ResourceB)- locked <0x22bf7fc0> (a com.ResourceA)at java.lang.Thread.run(Thread.java:722)<span style="color:#ff0000;">Found 1 deadlock.</span>

可以看得出，线程MyThread1锁住了资源ResourceA，并且请求资源ResourceB；线程MyThread2锁住了资源ResourceB，并且请求资源ResourceA，这样就导入了死锁。

解决这种死锁的办法是通过RestrantLock替代synchronized。

待续...

面试经历---Samp；G（2016年02月27日上午面试）相关推荐

面试经历---UC（2016年01月11日下午面试）
一年多前曾经去过UC面试,那时候没有通过面试,这次又去UC试试,做了一年半的电商平台开发,想看看这些大型的互联网公司的要求有多高. 下面详细列一下UC的JAVA笔试题和面试题. 一.JAVA笔试题 1 ...
面试经历---网易（2016年01月19日下午面试）
下面写上网易的面试情况. 1.nginx负载均衡的方式 (1).轮询(默认) 每个请求按时间顺序逐一分配到不同的后端服务器,如果后端服务器down掉,能自动剔除. (2).weight 指定轮询几率, ...
面试经历---广东耶萨智能科技股份有限公司（2016年01月11日上午面试）
广东耶萨智能科技股份有限公司是一家做跨境玩具贸易的公司,约我2016年1月11日上午过去面试. 一.笔试题 1. 写出下述语句的结果 Int a=1,b=0; System.out.printl ...
薛老师软考高项学员：2016年4月27日作业
薛老师软考高项学员:2016年4月27日作业 1.写全文:论信息系统项目的范围管理 2.写架构:论项目的计划与监控:论项目的进度管理. 转载于:https://blog.51cto.com/xueda ...
2016年8月27日星期六 --出埃及记 Exodus 16:28
2016年8月27日星期六 --出埃及记 Exodus 16:28 Then the LORD said to Moses, "How long will you refuse to ke ...
第一阶段笔试面试经历 0 offer 2021年9月21日
2021.09.21 从今年的8月13日投递了第一份简历之后,到现在收到了许多感谢信,还有一些信在路上,目前没有拿到过一个offer,基本上都是倒在一二面上.之前师傅和我说,如果一二面经常挂,说明自己 ...
虚拟现实设备排行榜（2016年3月27日）
VR虚拟现实设备/AR增强现实设备名称分辨率(单眼) 刷新率视野范围重量(g) 屏幕价格发售状态 VR设备名称 HTV Vive 1200*1080 90 110 380 OLED ￥68 ...
2017年3月27日上午学习日志
2017年3月27上午复习了高等数学,继续看了张宇高等数学基础班课程视频第一章极限与连续部分极限的定义和极限的性质,第二遍听课过程中能巩固之前所学内容,不懂的问题得以解决,印象也更加深刻,对复习有很大 ...
2016年02月29日
一.网络基础概念 1.1.个人主机(端口) -> 交换机(内网服务器 )-> 路由器 ->外网 1.2.资源分配外网ip:只要一个,给路由器的,路由器凭此连接外网内网ip:分配给各端 ...

面试经历---Samp；G（2016年02月27日上午面试）

面试经历---Samp；G（2016年02月27日上午面试）相关推荐

最新文章

热门文章