面试中线程相关问题（补充ing.....）

面试中线程相关问题（补充ing.....）

一、线程和进程的关系

1.基本概念

　　在并发性程序中，有两个基本的执行单元：进程和线程。在java编程语言中，并发编程大多数情况下都是和线程相关。然而，进程也是很重要的。 

　　进程的含义：在操作系统中，独立运行的应用程序或者可以说是一个服务

　　线程的含义：是进程中的一个执行单元

　　一个计算机系统中通常都有很多活动的进程和线程。这一点即使是在只有一个执行核心，并且在给定时刻只能执行一个线程的系统中都是存在的。单一核心的处理时间是由整个操作系统的“时间片”特性来在众多的进程和线程中共享的。

　　现在，计算机系统中有多个处理器或者是有多核处理器的情况越来越普遍。这就大大增强了系统执行多个进程和线程的并发性。

2.进程

　　一个进程就是一个独立的执行环境。进程有着完整的，私有的基本的运行时资源，尤其是每个进程都有自己的内存空间。 

　　进程通常会被看作是程序或者是应用程序的同义词。然而，用户看到的应用程序实际上可能是多个相互协作的进程。为了方便进程间通讯，绝大多数的操作系统都支持IPC（Inter Process Communication , 进程间通讯），诸如管道(pipe)和套接字(socket)。 IPC不仅可用于同一系统中进程间的相互通讯，还可以用于不同系统间的进程通讯。 

　　大多数的java虚拟机的实现都是作为一个单独的进程的。

　　通过使用ProcessBuilder，Java应用程序可以创建额外的进程。

3.线程

　　线程有时被称为是轻型的进程。进程和线程都提供了一种运行环境。但是创建一个新的线程比创建一个新的进程需要更少的资源。 

　　线程存在于进程之中——每个进程中至少有一个线程。同一进程的多个线程间共享进程的资源，包括内存和文件。这样做是出于效率的考虑，但是可能带来潜在的通信问题 

　　多线程是Java平台的一个重要特性。如果我们将进行诸如内存管理和信号处理的线程算上的“系统”线程计算上的话，那么每一个应用程序至少都有一个线程，或者是多个线程。但是从应用程序的编程人员的角度来看，我们总是从一个叫做主线程的线程开始。该线程能够创建其他的线程，比如我们最早写的带main方法的类，执行main方法，此时开启一个进程，该进程包含一个主线程main，然后可以在主线程中创建其他线程。

二、创建线程的三种方式

在java中有3种方式来创建并执行线程

1.通过继承java.lang.Thread类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。

2.通过Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

（3）调用线程对象的start()方法来启动该线程。

3.通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用Thread对象的start方法来启动线程

（5）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

三、Runnable接口和Thread类的区别

　　如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

　　总结：

　　实现Runnable接口比继承Thread类所具有的优势：

　　1）：适合多个相同的程序代码的线程去处理同一个资源

　　2）：可以避免java中的单继承的限制

　　3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

　　4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

注意：main方法其实也是一个线程。在java中所有的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个jvm，每一个jvm实例就是在操作系统中启动了一个进程。

四、Runnable接口和Callable接口的区别

Callable接口和Runnable接口相似，

区别就是Callable需要实现call方法，而Runnable需要实现run方法；并且，call方法还可以返回任何对象，无论是什么对象，JVM都会当作Object来处理。

但是如果使用了泛型，我们就不用每次都对Object进行转换了。

Runnable和Callable都是接口

不同之处：

1.Callable可以返回一个类型V，而Runnable不可以
2.Callable能够抛出checked exception,而Runnable不可以。
3.Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的
4.Callable和Runnable都可以应用于executors。而Thread类只支持Runnable.
上面只是简单的不同，其实这两个接口在用起来差别还是很大的。Callable与executors联合在一起，在任务完成时可立刻获得一个更新了的Future。而Runable却要自己处理

 

Future接口，一般都是取回Callable执行的状态用的。其中的主要方法：

cancel   取消Callable的执行，当Callable还没有完成时

get   获得Callable的返回值

isCanceled   判断是否取消了

isDone   判断是否完成

五、join()方法以及为什么要使用

1.概念

　　指等待某一线程终止。

2.使用方式。

　　join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

3.为什么要使用join()方法

　　在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

六、yield方法和sleep方法的区别

1、概念

        1）.sleep()

        使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有
        synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。

        2）.yield()

        该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

2、sleep()和yield()的区别

        1）.sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        2）.sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
        3）.另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

七、wait()方法和sleep()方法的区别

1、概念

       1）.wait() 

        首先wait()是属于Object类的方法，从源码给出的解释来看，wait()方法可以做到如下几点：

        （1）首先，调用了wait()之后会引起当前线程处于等待状状态。

        （2）其次，每个线程必须持有该对象的monitor。如果在当前线程中调用wait()方法之后，该线程就会释放monitor的持有对象并让自己处于等待状态。

        （3）如果想唤醒一个正在等待的线程，那么需要开启一个线程通过notify()或者notifyAll()方法去通知正在等待的线程获取monitor对象。如此，该线程即可打破等待的状态继续执行代码。

       2）.sleep()

        sleep()方法来自于Thread类，从源码给出的解释来看，sleep()方法可以做到如下几点：

        （1）首先，调用sleep()之后，会引起当前执行的线程进入暂时中断状态，也即睡眠状态。

        （2）其次，虽然当前线程进入了睡眠状态，但是依然持有monitor对象。

        （3）在中断完成之后，自动进入唤醒状态从而继续执行代码。

2、共同点： 

        1）. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 
        2）. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。 
        如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出
        InterruptedException，在catch() {} 中直接return即可安全地结束线程。 
        需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么
        该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。 

3、不同点： 

        1）. Thread类的方法：sleep(),yield()等 
        Object的方法：wait()和notify()等 
        2）. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 
        sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 
        3）. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 

4、sleep()和wait()方法的最大区别是：

        sleep()睡眠时，保持对象锁，仍然占有该锁；
        而wait()睡眠时，释放对象锁。
        但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

        sleep()方法:

        sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
        sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有
        被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
        在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 

        wait()方法:

        wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机
        锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
        wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
        wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。

八、什么是线程安全

        经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果。

        当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。代码本身封装了所有必要的正确性保障手段（互斥同步等），令调用者无需关心多线程的问题，更无需自己实现任何措施来保证多线程的正确调用。

九、如何实现线程安全？

1、互斥同步

       最常见的并发正确性保障手段，同步至多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个线程使用。

2、非阻塞同步

       互斥同步的主要问题就是进行线程的阻塞和唤醒所带来的性能问题，因此这个同步也被称为阻塞同步，阻塞同步属于一种悲观的并发策略，认为只要不去做正确的同步措施，就肯定会出问题，无论共享的数据是否会出现竞争。随着硬件指令的发展，有了另外一个选择，基于冲突检测的乐观并发策略，通俗的讲就是先进性操作，如果没有其他线程争用共享数据，那操作就成功了，如果共享数据有争用，产生了冲突，那就再进行其他的补偿措施（最常见的措施就是不断的重试，直到成功为止），这种策略不需要把线程挂起，所以这种同步也被称为非阻塞同步。

3、无同步方案

       简单的理解就是没有共享变量需要不同的线程去争用，目前有两种方案，一个是“可重入代码”，这种代码可以在执行的任何时刻中断它，转而去执行其他的另外一段代码，当控制权返回时，程序继续执行，不会出现任何错误。一个是“线程本地存储”，如果变量要被多线程访问，可以使用volatile关键字来声明它为“易变的“，以此来实现多线程之间的可见性。同时也可以通过ThreadLocal来实现线程本地存储的功能，一个线程的Thread对象中都有一个ThreadLocalMap对象，来实现KV数据的存储。

十、synchronized、Lock、ReentrantLock、ReadWriteLock

1、synchronized

1）.synchronized关键字用法：修饰方法

       a.成员方法

       

       某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 

       b.静态方法

       

       是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 简单的可以理解为将整个类都锁住了，除非该锁被释放，该类的所有的关键词synchronized修饰的静态方法、语句块均不可访问。

2）.修饰语句块

       

       除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 

3）.总结

       Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

       A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

       B．每个对象只有一个锁（lock）与之相关联。

       C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

总的来说

       1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。

       2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法

       3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

       4、对于同步，要时刻清醒在哪个对象上同步，这是关键。

       5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

       6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

       7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

2、Lock

       Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。

       读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

 

Lock接口提供的主要方法：

lock()  等待获取锁

lockInterruptibly()  可中断等待获取锁，synchronized无法实现可中断等待

tryLock() 尝试获取锁，立即返回true或false

tryLock(long time, TimeUnit unit)    指定时间内等待获取锁

unlock()      释放锁

newCondition()   返回一个绑定到此 Lock 实例上的 Condition 实例

关于Lock接口的实现，主要关注以下两个类

ReentrantLock

ReentrantReadWriteLock

3、ReentrantLock

       可重入锁，所谓的可重入锁，也叫递归锁，是指一个线程获取锁后，再次获取该锁时，不需要重新等待获取。ReentrantLock分为公平锁和非公平锁，公平锁指的是严格按照先来先得的顺序排队等待去获取锁，而非公平锁每次获取锁时，是先直接尝试获取锁，获取不到，再按照先来先得的顺序排队等待。

注意：ReentrantLock和synchronized都是可重入锁。

4、ReentrantReadWriteLock

可重入读写锁，指的是没有线程进行写操作时，多个线程可同时进行读操作，当有线程进行写操作时，其它读写操作只能等待。即“读-读能共存，读-写不能共存，写-写不能共存”。

在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。

ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁
线程进入读锁的前提条件：
    没有其他线程的写锁，
    没有写请求或者有写请求，但调用线程和持有锁的线程是同一个

线程进入写锁的前提条件：
    没有其他线程的读锁
    没有其他线程的写锁

到ReentrantReadWriteLock，首先要做的是与ReentrantLock划清界限。它和后者都是单独的实现，彼此之间没有继承或实现的关系。然后就是总结这个锁机制的特性了： 
     (a).重入方面其内部的WriteLock可以获取ReadLock，但是反过来ReadLock想要获得WriteLock则永远都不要想。 
     (b).WriteLock可以降级为ReadLock，顺序是：先获得WriteLock再获得ReadLock，然后释放WriteLock，这时候线程将保持Readlock的持有。反过来ReadLock想要升级为WriteLock则不可能，为什么？请参考A 
     (c).ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock，而WriteLock则是完全的互斥。这一特性最为重要，因为对于高读取频率而相对较低写入的数据结构，使用此类锁同步机制则可以提高并发量。 
     (d).不管是ReadLock还是WriteLock都支持Interrupt，语义与ReentrantLock一致。 
     (e).WriteLock支持Condition并且与ReentrantLock语义一致，而ReadLock则不能使用Condition，否则抛出UnsupportedOperationException异常。

十一、什么是ThreadLocal

详细介绍（转载）：http://blog.csdn.net/sonny543/article/details/51336457

十二、线程池及创建线程池的4种方式

1、什么是线程池

       线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中并等待下一次分配任务。

2、为什么需要线程池

         基于以下几个原因在多线程应用程序中使用线程是必须的：

         1）. 线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。

         2）. 线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。

         3）. 线程池根据当前在系统中运行的进程来优化线程时间片。

         4）. 线程池允许我们开启多个任务而不用为每个线程设置属性。

         5）. 线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。

         6）. 线程池可以用来解决处理一个特定请求最大线程数量限制问题。

3、线程池的概念

       影响一个多线程应用程序的相应时间的几个主要因素之一是为每个任务生成一个线程的时间。

       例如，一个Web Server 是一个多线程应用程序，它可以同时对多个客户端请求提供服务。让我们假设有十个客户端同时访问Web Server:

       a.如果服务执行一个客户端对应一个线程的策略，它将为这些客户端生成十个新线程，从创建第一个线程开始到在线程的整个生命周期管理它们都会增加系统开销。也有可能在某个时间计算机的资源耗尽。

       b. 相反的，如果服务端使用一个线程池来处理这些请求，那么当每次客户端请求来到后都创建一个线程的时间会节省下来。它可以管理已经创建的线程，如果线程池太忙的话也可以拒绝客户端请求。这是线程池背后的概念。

       现在回顾一下，影响设计一个多线程应用程序的因素有：

         1. 一个应用程序的响应时间。

         2. 线程管理资源的分配。

         3. 资源共享。

         4. 线程同步。

4、创建线程池的4种方式

       通过Executors工具类可以创建各种类型的线程池，如下为常见的四种：

       1）. newCachedThreadPool ：大小不受限，当线程释放时，可重用该线程；

       2）. newFixedThreadPool ：大小固定，无可用线程时，任务需等待，直到有可用线程；

       3）. newSingleThreadExecutor ：创建一个单线程，任务会按顺序依次执行；

       4）. newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行

十三、ThreadPoolExecutor（线程池）的内部工作原理

详细介绍（转载）：http://www.jb51.net/article/116521.htm