并发编程相关面试题二

一、进程、线程、协程之间的关系

 1、进程

　　电脑的应用程序，都是进程，它有自己的地址空间

　　包括文本区域（text region）数据区域（data region）和堆栈（stack region）

　　文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。

　　当程序处于IO阻塞的时候 程序会一起等。 三个状态 就绪、运行和阻塞

　　

2、线程

　　独立运行的程序片段,通常在一个进程中可以包含若干个线程，一个进程中至少有一个主线程,线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的程度。

　　

3、协程

　　相当于微线程.一个线程执行

　　协程极高的执行效率。因为子程序function内切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显

　　

二、进程和线程的区别与联系

    并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行。
    拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
    系统开销：多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。    
    线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。
    协程和线程区别：协程避免了无意义的调度，由此可以提高性能，但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多CPU的能力。

协程的特点在于是一个线程执行，那和多线程比，协程有何优势？　　

　　1.极高的执行效率：因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显；
　　2.不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

线程与进程的联系

    1.一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程；

    2.资源分配给进程，同一进程的所有线程共享该进程的所有资源；

    3.处理机分给线程，即真正在处理机上运行的是线程；

    4.线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

三、并发和并行之间的区别

　　解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

　　解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。

　　解释三：并行是在一台处理器上“同时”处理多个任务，并发是在多台处理器上同时处理多个任务。如 hadoop 分布式集群。

所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

　　

并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。

　　

　　并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在，并发能够在单处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只是要求程序假装同时执行多个操作（每个小时间片执行一个操作，多个操作快速切换执行）。

　　当有多个线程在操作时，如果系统只有一个 CPU，则它根本不可能真正同时进行一个以上的线程，它只能把 CPU 运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时,其它线程处于挂起状态.这种方式我们称之为并发（Concurrent）。

　　当系统有一个以上 CPU 时，则线程的操作有可能非并发。当一个 CPU 执行一个线程时，另一个 CPU 可以执行另一个线程，两个线程互不抢占 CPU 资源，可以同时进行，这种方式我们称之为并行（Parallel）。

四、Java中多线程实现的方式

Java多线程实现方式主要有四种：

1、继承Thread类

　　Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法

2、实现Runnable接口

　　如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start(); 

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {  
　　if (target != null) {  
　　 target.run();  
　　}  
}  

3、实现Callable接口通过FutureTask包装器来创建Thread线程

Callable接口（也只有一个方法）定义如下：   

public interface Callable<V>   { 
  V call（） throws Exception;  
} 

public class SomeCallable<V> extends OtherClass implements Callable<V> {
    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}

Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   
//至此，一个线程就创建完成了。

4、使用ExecutorService、Callable、Future实现有返回结果的多线程。

　　ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，有了这种特征就不需要再为了得到返回值而大费周折了。而且自己实现了也可能漏洞百出。

　　可返回值的任务必须实现Callable接口。类似的，无返回值的任务必须实现Runnable接口。

　　执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。

注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

　　再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

详细案例请见：https://www.cnblogs.com/felixzh/p/6036074.html

 五、Callable和Future模式

详情在本人另一篇博客：https://www.cnblogs.com/Zzzzn/p/12552670.html

1、Callable

　　在Java中，创建线程一般有两种方式，一种是继承Thread类，一种是实现Runnable接口。然而，这两种方式的缺点是在线程任务执行结束后，无法获取执行结果。我们一般只能采用共享变量或共享存储区以及线程通信的方式实现获得任务结果的目的。 不过，Java中，也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果。

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

2、Future常用方法

　　V get() ：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

　　V get(Long timeout , TimeUnit unit) ：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。

　　boolean isDone() ：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。

　　boolean isCanceller() ：如果任务完成前被取消，则返回true。

　　boolean cancel(boolean mayInterruptRunning) ：如果任务还没开始，执行cancel(...)方法将返回false；如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；当任务已经完成，执行cancel(...)方法将返回false。mayInterruptRunning参数表示是否中断执行中的线程。

　　通过方法分析我们也知道实际上Future提供了3种功能：

　　　　（1）能够中断执行中的任务

　　　　（2）判断任务是否执行完成

　　　　（3）获取任务执行完成后额结果。

3、Future模式

　　Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑

　　Futrure模式:对于多线程，如果线程A要等待线程B的结果，那么线程A没必要等待B，直到B有结果，可以先拿到一个未来的Future，等B有结果是再取真实的结果。

　在多线程中经常举的一个例子就是：网络图片的下载，刚开始是通过模糊的图片来代替最后的图片，等下载图片的线程下载完图片后在替换。而在这个过程中可以做一些其他的事情。

　　首先客户端向服务器请求RealSubject，但是这个资源的创建是非常耗时的，怎么办呢？这种情况下，首先返回Client一个FutureSubject,以满足客户端的需求，于此同时呢，Future会通过另外一个Thread 去构造一个真正的资源，资源准备完毕之后，在给future一个通知。如果客户端急于获取这个真正的资源，那么就会阻塞客户端的其他所有线程，等待资源准备完毕。

六、线程池创建的方式

1、newCachedThreadPool

　　newCachedThreadPool：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用；如果没有，就创建一个新的线程加入池中，缓存型池通常用于执行一些生存期很短的异步型任务；

package com.zn.threadPoolTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewCachedThreadPoolTest {
    public static void main(String[] args) {
        // 无限大小线程池 jvm自动回收
        //构建一个线程池，可以重复利用线程
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 1; i <=10 ; i++) {
            //创建线程池
            executorService.execute(()->{
                System.out.println("创建线程池"+Thread.currentThread().getName());
            });
        }
    }
}

控制台效果：

　　

总结：

　　线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

2、newFixedThreadPool

　　newFixedThreadPool：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程；

package com.zn.threadPoolTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewFixedThreadPoolTest {
    public static void main(String[] args) {
        //构建线程池对象
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            //创建线程
            executorService.execute(() -> {
                System.out.println("创建线程：" + Thread.currentThread().getName());
            });
        }
    }
}

控制台效果：

　　

总结：

　　因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

　　定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

3、newScheduledThreadPool

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

package com.zn.threadPoolTest;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolTest {
    public static void main(String[] args) {
        //创建一个线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 10; i++) {
            scheduledExecutorService.schedule(()->{
                System.out.println("创建线程："+Thread.currentThread().getName());
            },1000, TimeUnit.MILLISECONDS);
        }
    }
}

控制台效果：

　　

总结：

　　输出结果时，表示延迟3秒执行。

4、newSingleThreadExecutorPool

　　newSingleThreadExecutorPool：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行；

package com.zn.threadPoolTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewSingleThreadExecutorTest {
    public static void main(String[] args) {
        //创建一个线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            executorService.execute(()->{
                System.out.println("创建线程："+Thread.currentThread().getName());
            });
        }
    }
}

控制台效果：