003、Java面试之进程线程

1、线程和进程的概念、并行和并发的概念

• 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
• 线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

• 并行：多个线程可以同时执行，每一个时间段，可以有多个线程同时执行。
• 并发：多个线程同时竞争一个位置，竞争到的才可以执行，每一个时间段只有一个线程在执行。

 

• 几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是指一个程序。程序和进程的主要区别：程序是一个静态的指令集合，进程则是正在系统中活动的指令集合。换句话说，运行中的程序就是进程。
• 进程具有三个重要的性质：独立性、动态性、并发性
• 独立性：经常在操作系统中独立存在，拥有独立的资源和私有的地址空间。没有经过进程自身允许，其它用户进程不能直接访问进程的地址空间。
• 动态性：进程是运行中的程序，具有自己的生命周期和各种不同状态。
• 并发性：多个进程可以在单个处理器上并发执行，互不影响。所谓并发(concurrency)指的是同一时刻只能执行一条指令，但多个进程可以快速的切换执行，使得宏观上具有多个进程同时执行的效果，这种交错执行称为上下文切换。并行(parallel)则指同一时刻有多条指令在多个处理器上同时执行
• 一个操作系统可以同时执行多个任务，每个任务就是进程。进程可以同时执行多个任务，每个任务就是线程。

2、创建线程的方式及实现

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口

继承Thead类

• 创建继承自Thread类的子类并重写Thread类的run方法
• 通过创建该子类的对象，获得线程对象
• 调用线程对象的start()方法启动线程

package com.demo.thread;
public class ThreadDemo extends Thread {
    public ThreadDemo(String name) {
        super(name);
    }
    @Override
    public void run() {
        int i = 100;
        while (i > 0) {
            i--;
            System.out.println(String.format("%s：第%d次调用：", getName(), i));
        }
    }
    public static void main(String[] args) {
        ThreadDemo demo1 = new ThreadDemo("A");
        ThreadDemo demo2 = new ThreadDemo("B");
        demo1.start();
        demo2.start();
    }
}

实现Runnable接口

• 定义Runnable接口的实现类并重写run()方法
• 创建实现类的对象，并以此Runnable对象作为Thread的target创建Thread对象，即线程对象
• 调用线程对象的start()方法启动线程

package com.demo.thread;
public class RunnableDemo implements Runnable {
    private String name;
    public RunnableDemo(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        int i = 100;
        while (i > 0) {
            i--;
            System.out.println(String.format("%s：第%d次调用", name, i));
        }
    }
    public static void main(String[] args) {
        RunnableDemo demo1 = new RunnableDemo("A");
        RunnableDemo demo2 = new RunnableDemo("B");
        new Thread(demo1).start();
        new Thread(demo2).start();
    }
}

实现Callable接口

• 创建Callable接口的实现类并实现call()方法,该方法具有返回值
• 创建Callable实现类的对象，使用该Callable示例创建FutureTask的对象
• 以FutureTask对象作为Thread的target创建Thread对象，获得线程对象
• 调用线程对象的start()方法启动线程
• 调用FutureTask对象的get()方法获得线程运行结果

package com.demo.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableDemo implements Callable<String> {
    private String name;
    public CallableDemo(String name) {
        this.name = name;
    }
    @Override
    public String call() throws Exception {
        int i = 100;
        while (i > 0) {
            i--;
            System.out.println(String.format("%s：第%d次调用", name, i));
        }
        return String.format("%s：调用结束", name);
    }
    public static void main(String[] args){
        try{
        CallableDemo demo1 = new CallableDemo("a");
        FutureTask<String> futureTask1 = new FutureTask<>(demo1);
        Thread thread1= new Thread(futureTask1);
        CallableDemo demo2 = new CallableDemo("b");
        FutureTask<String> futureTask2 = new FutureTask<>(demo2);
        Thread thread2 = new Thread(futureTask2);
        thread1.start();
        thread2.start();
        System.out.println(futureTask1.get());
        System.out.println(futureTask2.get());
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(ExecutionException  e){
            e.printStackTrace();
        }
    }
}

3、进程间通信的方式

• 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。
• IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。

 

4、说说 CountDownLatch、CyclicBarrier 原理和区别

5、说说 Semaphore 原理

6、说说 Exchanger 原理

7、ThreadLocal 原理分析，ThreadLocal为什么会出现OOM，出现的深层次原理

8、讲讲线程池的实现原理

9、线程池的几种实现方式

10、线程的生命周期，状态是如何转移的