1、stop()和suspend()方法为何不推荐使用？

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。

suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

2、sleep()和wait()有什么区别?

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。

3、同步和异步有何异同，在什么情况下分别使用他们？

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

4、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

  • 其他方法前是否加了synchronized关键字，如果没加，则能。
  • 如果这个方法内部调用了wait，则可以进入其他synchronized方法。
  • 如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。
  • 如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。

    5、简述synchronized和java.util.concurrent.locks.Lock的异同？

    主要相同点：Lock能完成synchronized所实现的所有功能。
    主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。
    synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。
    举例说明（对下面的题用lock进行了改写） ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest { /**

  1. * @param args
  2. */
  3. private int j; 
  4. private Lock lock = new ReentrantLock(); 
  5. public static void main(String[] args) { 
  6.     ThreadTest tt = new ThreadTest(); 
  7.     for(int i=0;i<2;i++){ 
  8.         new Thread(tt.new Adder()).start(); 
  9.         new Thread(tt.new Subtractor()).start(); 
  10.     }
  11. } 
  13. private class Subtractor implements Runnable{
  14.     @Override
  15.     public void run() {
  16.         while(true){
  17.             /*synchronized (ThreadTest.this) { 
  18.                 System.out.println("j--=" + j--);
  19.             //这里抛异常了，锁能释放吗？
  20.             }*/ 
  21.             lock.lock(); 
  22.             try{
  23.                 System.out.println("j--="+ j--);
  24.             }finally{ 
  25.                 lock.unlock();
  26.             }
  27.         }
  28.     }
  29. }
  31. private class Adder implements Runnable {
  32.     @Override
  33.     public void run() {
  34.         while(true){
  35.             /*synchronized (ThreadTest.this) { 
  36.                 System.out.println("j++=" + j++);
  37.             }*/ 
  38.             lock.lock(); 
  39.             try{
  40.                 System.out.println("j++="+ j++);
  41.             }finally{
  42.                 lock.unlock();
  43.             }
  44.         }
  45.     }
  46. }

}

  1. <a name="Gnaga"></a>
  2. # 6、概括的解释下线程的几种可用状态。
  4. - 新建new。
  5. - 就绪 放在可运行线程池中，等待被线程调度选中，获取 cpu。
  6. - 运行 获得了 cpu。
  7. - 阻塞<br />
  8.    - 等待阻塞 执行 wait() 。
  9.    - 同步阻塞 获取对象的同步琐时，同步锁被别的线程占用。
  10.    - 其他阻塞 执行了 sleep() 或 join() 方法)。
  11. - 死亡。
  12. <a name="pEG42"></a>
  13. # 7、什么是ThreadLocal?**
  14. ThreadLocal 用于创建线程的本地变量，一个对象的所有线程会共享它的全局变量，所以这些变量不是线程安全的，可以使用同步技术。但是当不想使用同步的时候，可以选择 ThreadLocal变量。
  16. 每个线程都会拥有他们自己的 Thread 变量，它们可以使用 get()\set() 方法去获取他们的默认值或者在线程内部改变他们的值。ThreadLocal 实例通常是希望它们同线程状态关联起来是 private static 属性。
  17. <a name="Ye6XB"></a>
  18. # 8、run()和start() 区 别 。**
  19. **run( )：**只是调用普通 run 方法
  21. **start( )：**启动了线程, 由 Jvm 调用 run 方法
  23. 启动一个线程是调用 start() 方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM调度并执行。这并不意味着线程就会立即运行。run() 方法可以产生必须退出的标志来停止一个线程。
  24. <a name="OxOYL"></a>
  25. # 9、线程同步的方法。**
  26. **wait()：**使一个线程处于等待状态，并且释放所持有的对象的lock。 <br />**sleep()：**使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException 异常。 **notify()：**唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且不是按优先级。<br />**notityAll()：**唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
  27. <a name="s7Nvd"></a>
  28. # 10、线程调度和线程控制。**
  29. 线程调度（优先级）:
  31. 与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取 CPU 资源的概率较大，优先级低的并非没机会执行。线程的优先级用 1-10 之间的整数表示，数值越大优先级越高，默认的优先级为 5。在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。
  33. 线程控制<br />**sleep( ) **// 线程休眠 <br />**join( ) **// 线程加入 <br />**yield( ) **// 线程礼让<br />**setDaemon( ) **// 线程守护<br />中断线程<br />**stop( )、interrupt( ) **==(首先选用)==
  34. <a name="5mU7q"></a>
  35. # 11、什么是线程饿死，什么是活锁？
  36. 当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。<br />JavaAPI 中线程活锁可能发生在以下情形：
  38. - 当所有线程在序中执行Object.wait(0)，参数为 0 的 wait 方法。程序将发生 活锁直到在相应的对象上有线程调用 Object.notify() 或者Object.notifyAll()。
  39. - 当所有线程卡在无限循环中。
  40. <a name="3Baqj"></a>
  41. # 12、多线程中的忙循环是什么?
  42. 忙循环就是程序员用循环让一个线程等待，不像传统方法 wait(), sleep() 或 yield() 它们都放弃了 CPU 控制，而忙循环不会放弃 CPU，它就是在运行一个空循环。这么做的目的是为了保留 CPU 缓存。
  44. 在多核系统中，一个等待线程醒来的时候可能会在另一个内核运行，这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。
  45. <a name="VuOjB"></a>
  46. # 13、volatile变量是什么？volatile变量和 atomic变量有什么不同？**
  47. volatile则是保证了所修饰的变量的可见。因为 volatile 只是在保证了同一个变量在多线程中的可见性，所以它更多是用于修饰作为开关状态的变量，即 Boolean 类型的变量。
  49. volatile 多用于修饰类似开关类型的变量、Atomic 多用于类似计数器相关的变量、其它多线程并发操作用 synchronized关键字修饰。
  51. volatile 有两个功用：<br />
  53. 1. 这个变量不会在多个线程中存在复本，直接从内存读取。
  54. 1. 这个关键字会禁止指令重排序优化。也就是说，在volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
  55. <a name="126VT"></a>
  56. # 14、volatile类型变量提供什么保证？能使得一个非原子操作变成原子操作吗？**
  57. volatile 提供happens-before 的保证，确保一个线程的修改能对其他线程是可见的。
  59. 在 Java 中除了 long 和 double 之外的所有基本类型的读和赋值，都是原子性操作。而 64 位的 long 和 double 变量由于会被 JVM 当作两个分离的 32 位来进行操作，所以不具有原子性，会产生字撕裂问题。但是当定义 long 或 double 变量时， 如果使用 volatile 关键字，就会获到（简单的赋值与返回操作的）原子性。
  60. <a name="XnF7S"></a>
  61. # 15、线程池中的corenum和maxnum有什么不同？
  62. (1) 直接提交的队列：该功能由SynchronizedQueue对象提供。SynchronizedQueue是一个特殊的阻塞队列。SynchronizedQueue没有容量，每一个插入操作都要等待一个相应的删除操作，反之每一个删除操作都需要等待对应的插入操作。使用SynchronizedQueue时提交的任务不会被真实的保存，而总是将新任务提交给线程执行，如果没有空闲的线程则尝试创建新的线程，如果线程数量达到最大值就执行决绝策略。使用SynchronizedQueue队列通常要设置很大的maxnumPoolSize，否则很容易执行拒绝策略。可以当做大小为0的队列来理解。<br />(2) 有界的任务队列：有界的任务队列可以使用ArrayBlockingQueue实现。当使用有界的任务队列时，若有新的任务需要执行，如果线程池的实际线程数小于核心线程数，则有优先创建新的线程，若大于核心线程数，则会将新任务加入等待队列。若队列已满，无法加入则在总线程数不大于最大线程数的前提下，创建新的线程。若大于最大线程数，则执行拒绝策略。也就是说，有界队列仅当任务队列满时才可能将线程数提升到核心线程数只上，否则确保线程数维持在核心线程数大小。<br />(3) 无界任务队列：无界任务队列可以通过LinkedBlockingQueue类来实现。与有界队列相比，除非系统资源耗尽，否则无界队列不存在任务入队失败的情况。当有新的任务到来，系统的线程数小于核心线程数时线程池会生成新的线程执行任务，但当系统线程数大于核心线程数后，就不会继续增加。若后续有新的任务，则将任务放入无界队列中等待。<br />(4) 优先任务队列：优先任务队列是带有执行优先级的队列，通过PriorityBlockingQueue实现，可以控制任务的执行先后顺序，是一个特殊的无界队列。无论是有界队列还ArrayBlockingQueue还是未指定大小的无界队列LinkedBlockingQueue，都是按照先进先出算法处理任务的，而有限队列则可以根据任务自身的优先级顺序执行，在确保系统性能的同时，也能有很好的质量保证。<br />回过头看Executor框架提供了几种线程池，newFixedThreadPool()返回的固定大小线程池中核心线程数和最大线程数一样，并且使用了无界队列。因为对于固定大小的线程池来说，不存在线程数量的动态变化，所以最大线程数等于核心线程数。同时，使用无界队列存放无法立即执行的任务，当任务提交非常频繁时，队列可能迅速膨胀，从而耗尽系统资源。<br />newSingleThreadExecutor()返回的单线程线程池，是固定大小线程池的一种退化，只是简单的将线程池数量设置为1。newCachedThreadExecutor()返回核心线程数为0，最大线程数为无穷大的线程池。使用直接提交队列SynchronizedQueue。当Executor提供的线程池不满足使用场景时，则需要使用自定义线程池，选择合适的任务队列来作为缓冲。不同的并发队列对系统和性能的影响均不同。
  63. <a name="3lvz2"></a>
  64. # 16、多线程缺点？
  65. 1、将给定的工作量划分给过多的线程会造成每个线程的工作量过少，因此可能导致线程启动和终止时的开销比程序实际工作的开销还要多；<br />2、过多并发线程的存在将导致共享有限硬件资源的开销增大。<br />线程相对于进程的优点：1、开销小 2、资源共享性好。<br />线程相对于进程的缺点：1、共享资源需要耗费一定的锁资源，同步相对复杂。2、一个线程崩溃可能导致整个进程崩溃，这个当然是自己的应用程序有问题
  66. <a name="F3H57"></a>
  67. # 17、可重入锁 公平锁 读写锁
  68. <a name="4YEnG"></a>
  69. ## 1.可重入锁
  70. 如果锁具备可重入性，则称作为可重入锁。<br />像Synchronized和ReentrantLock都是可重入锁，可重入性实际上表明了锁的分配机制：<br />基于线程的分配，而不是基于方法调用的分配。<br />举个简单的例子，当一个线程执行到某个Synchronized方法时，比如说method1，而在method1中会调用另外一个Synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。
  71. ```java
  72. class MyClass {
  73.     public synchronized void method1() {
  74.         method2();
  75.     }
  76.     public synchronized void method2() {
  78.     }
  79. }

上述代码中的两个方法method1和method2都用Synchronized修饰了。
假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是Synchronized方法，假如Synchronized不具备可重入性，此时线程A需要重新申请锁。
但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。
而由于Synchronized和Lock都具备可重入性，所以不会发生上述现象。

2.可中断锁

可中断锁：顾名思义，就是可以响应中断的锁。
在Java中，Synchronized就不是可中断锁，而Lock是可中断锁。
如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。
在前面演示LockInterruptibly()的用法时已经体现了Lock的可中断性。

3.公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。
非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。
在Java中，Synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。
而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。这一点由构造函数可知：

  1. public ReentrantLock() {
  2.     sync = new NonfairSync();
  3. }
  4. public ReentrantLock(boolean fair) {
  5.     sync = (fair)? new FairSync() : new NonfairSync();
  6. }

在ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。
可以在创建ReentrantLock对象时，通过知道布尔参数来决定使用非公平锁还是公平锁。
如果参数为true表示为公平锁，为fasle为非公平锁。默认情况下，如果使用无参构造器，则是非公平锁。
另外在ReentrantLock类中定义了很多方法，比如：

  1. isFair() //判断锁是否是公平锁
  2. isLocked() //判断锁是否被任何线程获取了
  3. isHeldByCurrentThread() //判断锁是否被当前线程获取了
  4. hasQueuedThreads() //判断是否有线程在等待该锁

在ReentrantReadWriteLock中也有类似的方法，同样也可以设置为公平锁和非公平锁。
ReentrantReadWriteLock并未实现Lock接口，它实现的是ReadWriteLock接口。

4.读写锁

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。
正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
可以通过readLock()获取读锁，通过writeLock()获取写锁。