Java多线程问题

Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?

sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态

怎么产生死锁，如何解决死锁原因？

所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。

死锁产生的原因？

（1）互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
（2） 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
（3） 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的战友。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

解决死锁

1.如果想要打破互斥条件，我们需要允许进程同时访问某些资源，这种方法受制于实际场景，不太容易实现条件。

2.打破不可抢占条件，这样需要允许进程强行从占有者那里夺取某些资源，或者简单一点理解，占有资源的进程不能再申请占有其他资源，必须释放手上的资源之后才能发起申请，这个其实也很难找到适用场景。

3.进程在运行前申请得到所有的资源，否则该进程不能进入准备执行状态。这个方法看似有点用处，但是它的缺点是可能导致资源利用率和进程并发性降低。

4.避免出现资源申请环路，即对资源事先分类编号，按号分配。这种方式可以有效提高资源的利用率和系统吞吐量，但是增加了系统开销，增大了进程对资源的占用时间。

进程与线程？并行与并发？

进程代表一个运行中的程序，是资源分配与调度的基本单位。进程有三大特性：

1、独立性：独立的资源，私有的地址空间，进程间互不影响。

2、动态性：进程具有生命周期。

3、并发性：多进程可以在单核CPU上并发运行。

线程代表进程中的一个顺序执行流，多线程就是一个进程中的多个顺序执行流。线程也被称为轻量级的进程，是系统运行的基本单位。

多线程的优势（进程线程区别）：

1、进程之间不能共享内存，线程之间共享内存更容易，多线程可协作完成进程工作；

2、创建进程进行资源分配的代价较创建线程要大得多，所以多线程在高并发环境中效率更高。

 

并行与并发：

并行是指：多核多CPU或多机器处理同一段处理逻辑的时候，同一时刻多个执行流共同执行。

并发是指：通过CPU的调度算法，使用户感觉像是同时处理多个任务，但同一时刻只有一个执行流占用CPU执行。即使多核多CPU环境还是会使用并发，以提高处理效率。

主要的CPU调度算法有如下两种：

1、分时调度：每个线程轮流获取CPU使用权，各个线程平均CPU时间片。

2、抢占式调度：Java虚拟机使用的就是这种调度模型。这种调度方式会根据线程优先级，先调度优先级高的线程，如果线程优先级相同，会随机选取线程执行。

 

PCB是什么？

进程控制块，是进程最重要的数据结构，记录着进程的标识、调度信息、控制信息、以及处理机状态。PCB会在进程创建时创建、进程消亡时消亡，伴随PCB整个生命周期。

其中需要了解的有以下几点：

1、进程标识符用于唯一的标识一个进程。一个进程通常有两种标识符：内部标识符和外部标识符。

2、处理机状态信息主要是由处理机的各种寄存器中的内容组成的。处理机在运行中，许多信息都是放在寄存器中的。当处理机被中断时，所有的这些信息都保存在PCB中，以便在该进程重新执行时，能从断点继续执行。

3、进程调度信息包括进程状态、进程优先级、进程调度所需的其他信息，事件（阻塞原因）。

4、进程控制信息包括程序和数据的地址、进程同步和通信机制、资源清单、链接指针。

5、进程控制块的组织方式为链接方式、索引方式。

Java创建线程的四种方式？

1、继承Thread类，实现run()方法。

2、实现Runnable接口，实现run()方法。Runnable实例对象作为Thread构造方法中的target参数传入，充当线程执行体。这种方式适用于多个线程共享资源的情况。

3、实现Callable<Class>接口，实现call()方法。

 

call()方法与run()方法的两个主要区别：

1、call()方法可以有返回值，且返回值类型需要与声明接口时的泛型类型一致。

2、call()方法可以抛出异常。

使用这种方式，步骤较前两种方式比较复杂：

1、在声明接口时就需要指定泛型类型，且call()方法的返回值类型要与泛型类型一致。

2、使用FutureTask<Class>封装Callable实例对象，作为Thread构造方法中的target参数传入。

3、在调用start()后，可使用FutureTask的get()方法获取返回值。

4、实现java.util.concurrent.ThreadFactory接口，实现newThread(Runnable r)方法，自定义创建细节。

 

Java终止线程的四种方式？

1、自然终止，run()方法执行结束后，线程自动终止。

2、使用stop()方法，已经被弃用。

3、使用volatile 标志位（其实就是外部控制的自然死亡）。

4、使用interrupt()方法中断运行态和阻塞态线程。（关于interrupt()，调用interrupt()方法，立刻改变的是中断状态，但如果不是在阻塞态，就不会抛出异常；如果在进入阻塞态后，中断状态为已中断，就会立刻抛出异常。但是在获取synchronized锁的过程中不可被中断。详解可参看：http://blog.csdn.net/zhangliangzi/article/details/52485319）

注意：当线程抛出一个未被捕获的异常或错误时，线程会异常终止。

 

sleep()方法与wait()方法区别是什么？wait()方法为什么属于Object类？

它们的都是使线程“等待”一段时间，但是：

sleep()方法是Thread类下的方法，控制线程休眠，休眠过程中不会释放锁，sleep()时间到后进入就绪态等待调度。

wait()方法是Object类下的方法，控制线程等待，等待过程会释放锁，被notify()后会进入就绪态等待调度。

 

至于wait()方法为什么属于Object类，而不是Thread类，是因为：

wait()方法用于多个线程争用一把锁（一般为Synchronized锁住的对象）的情况，同一时刻只有一个线程能够获得锁，其他线程就要在线程队列等待。作用对象就是被锁住的对象，所以线程队列的维护工作应该交给Object。如果交给Thread，那么每个Thread都要知道其他Thread的状态，这并不合理。

 

start()方法与run()方法区别？

start()方法用于启动线程，会把线程状态由新建态转为就绪态，为线程分配线程私有的方法栈、程序计数器等资源，而start()方法会自动把run()方法作为线程执行体。

run()方法本身与普通方法并无二致，直接调用run()方法不会具有线程的意义。

 

简述线程的生命周期

1、新建态，通过上述几种方式创建了具有线程执行体的Thread对象，就进入了新建态。

2、就绪态，调用Thread对象的start()方法，就会为线程分配线程私有的方法栈、程序计数器资源，如果得到CPU资源，线程就会由就绪态转为运行态。换句话说，就绪态的线程获得了除CPU之外的所有必须资源。

3、运行态，就绪态线程得到CPU资源就会转为运行态，执行run()方法。当然，在调用yield()线程让步的情况，线程会由运行态转到就绪态，但这个过程可能是及其短暂的，如果当前线程拥有较高的优先级，即使让步后，它也会直接转为运行态。

4、阻塞态，会导致阻塞态的方法主要有：sleep()方法、wait()方法、join()方法、等待获取锁、等待IO等情况。在这些情况被处理后，就会转为就绪态，等待调度。

5、终止态，包括第四个问题所说的几种情况。

 

后台线程是什么？有什么应用？

后台线程如其名，就是在后台工作的线程，它的任务是为其他线程提供服务，也叫做“守护线程”与“精灵线程”。通过在start()方法调用前，调用setDeamon(true)方法，将线程设置为后台线程。后台线程会在前台线程死亡后由JVM通知死亡。

后台线程最大的应用就是垃圾回收线程，它是一个典型的后台线程。

 

Java常见的锁类型有哪些？请简述其特点。

1、synchronized对象同步锁：synchronized是对对象加锁，可作用于对象、方法（相当于对this对象加锁）、静态方法（相当于对Class实例对象加锁，锁住的该类的所有对象）以保证并发环境的线程安全。同一时刻只有一个线程可以获得锁。

其底层实现是通过使用对象监视器Monitor，每个对象都有一个监视器，当线程试图获取Synchronized锁定的对象时，就会去请求对象监视器（Monitor.Enter()方法），如果监视器空闲，则请求成功，会获取执行锁定代码的权利；如果监视器已被其他线程持有，线程进入同步队列等待。

2、Lock同步锁：与synchronized功能类似，可从Lock与synchronized区别进行分析：

1、Lock可以通过tryLock()方法非阻塞地获取锁而。如果获取了锁即立刻返回true，否则立刻返回false。这个方法还有加上定时等待的重载方法tryLock(long time, TimeUnit unit)方法，在定时期间内，如果获取了锁立刻返回true，否则在定时结束后返回false。在定时等待期间可以被中断，抛出InterruptException异常。而Synchronized在获得锁的过程中是不可被中断的。

2、Lock可以通过lockInterrupt()方法可中断的获取锁，与lock()方法不同的是等待时可以响应中断，抛出InterruptException异常。

3、Synchronized是隐式的加锁解锁，而Lock必须显示的加锁解锁，而且解锁应放到finnally中，保证一定会被解锁，而Synchronized在出现异常时也会自动解锁。但也因为这样，Lock更加灵活。

4、Synchronized是JVM层面上的设计，对对象加锁，基于对象监视器。Lock是代码实现的。

3、可重入锁：ReentrantLock与Synchronized都是可重入锁。可重入意味着，获得锁的线程可递归的再次获取锁。当所有锁释放后，其他线程才可以获取锁。

4、公平锁与非公平锁：“公平性”是指是否等待最久的线程就会获得资源。如果获得锁的顺序是顺序的，那么就是公平的。不公平锁一般效率高于公平锁。ReentrantLock可以通过构造函数参数控制锁是否公平。

5、ReentrantReadWriteLock读写锁：是一种非排它锁， 一般的锁都是排他锁，就是同一时刻只有一个线程可以访问，比如Synchronized和Lock。读写锁就多个线程可以同时获取读锁读资源，当有写操作的时候，获取写锁，写操作之后的读写操作都将被阻塞，直到写锁释放。读写锁适合写操作较多的场景，效率较高。

6、乐观锁与悲观锁：在Java中的实际应用类并不多，大多用在数据库锁上，可参看：http://blog.csdn.net/sdyy321/article/details/6183412

7、死锁：是当两个线程互相等待获取对方的对象监视器时就会发生死锁。一旦出现死锁，整个程序既不会出现异常也不会有提示，但所有线程都处于阻塞状态。死锁一般出现于多个同步监视器的情况。

 

volatile与automicInteger是什么？如何使用？

在并发环境中有三个因素需要慎重考量，原子性、可见性、有序性。

volatile主要用于解决可见性，它修饰变量，相当于对当前语句前后加上了“内存栅栏”。使当前代码之前的代码不会被重排到当前代码之后，当前代码之后的指令不会被重排到当前代码之前，一定程度保证了有序性。而volatile最主要的作用是使修改volatile修饰的变量值时会使所有线程中的缓存失效，并强制写入公共主存，保证了各个线程的一致。可以看做是轻量级的Synchronized。详情可参看：http://www.cnblogs.com/dolphin0520/p/3920373.html。

automicXXX主要用于解决原子性，有一个很经典的问题：i++是原子性的操作码？答案是不是，它其实是两步操作，一步是取i的值，一步是++。在取值之后如果有另外的线程去修改这个值，那么当前线程的i值就是旧数据，会影响最后的运算结果。使用automicXXX就可以非阻塞、保证原子性的对数据进行增减操作。详情可参看：http://ifeve.com/java-atomic/

 

注：在此列举的只是Java多线程最基础的知识，也是面试官最常问到的，先打牢基础，再去探讨底层原理或者高级用法，除了这十个问题，在此再推荐一些其他的资料：

JVM底层又是如何实现synchronized的：http://www.open-open.com/lib/view/open1352431526366.html

Java线程池详解：http://blog.csdn.net/zhangliangzi/article/details/52389766

Java线程池深度解析：http://www.cnblogs.com/dolphin0520/p/3932921.html

ConcurrentHashMap原理分析：http://www.cnblogs.com/ITtangtang/p/3948786.html

Java阻塞队列详解：http://ifeve.com/java-blocking-queue/