java多线程并发系列--基础知识点（笔试、面试必备）（上）

多线程和并发是求职大小厂面试中必问的知识点，其涉及到点很多，难度很大。有些人面对这些问题有点迷茫，为了解决这情况，总结了一下java多线程并发的基础知识点。而且要想深入研究java多线程并发也必须先掌握基础知识，可为后续各个模块深入研究做好做好准备。现在废话不多说，各位看官请查看基础知识点，后续还有源码解析（synchronize底层原理，线程池原理，Lock，AQS，同步、并发容器等源码解析）。

1 基本概念

 程序： 是计算机指令的集合，它以文件的形式存储在磁盘上,即程序是静态的代码

 进程：

• 是一个程序在其自身的地址空间中的一次执行活动,是系统运行程序的基本单位
• 进程是资源申请、调度和独立运行的单位

 线程：

• 是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
• 线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区 别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这 使得线程间的通信远较进程简单。

 三者之间的关系:

• 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
• 从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

内存机制可查看文章《推荐收藏系列：一文理解JVM虚拟机（内存、垃圾回收、性能优化）解决面试中遇到问题》

2 线程组成

组成部分：虚拟CPU、执行的代码以及处理的数据。

3 线程与进程区别

 进程： 指系统中正在运行中的应用程序，它拥有自己独立的内存空间；

 线程： 是指进程中一个执行流程，一个进程中允许同时启动多个线程，他们分别执行不同的任务,多个线程共享内存，从而极大地提高了程序的运行效率;

 主要区别：

• 每个进程都需要操作系统为其分配独立的内存地址空间
• 而同一进程中的所有线程在同一块地址空间中，这些线程可以共享数 据，因此线程间的通信比较简单，消耗的系统开销也相对较小

4 为什么要使用多线程

 使用多线程好处：

• 可以同时并发执行多个任务
• 程序的某个功能部分正在等待某些资源的时候，此时又不愿意因为等待而造成程序暂停，那么就可以创建另外的线程进行其它的工作；
• 多线程可以最大限度地减低CPU的闲置时间，从而提高CPU的利用率；

5 主线程

Java程序启动时，一个线程立刻运行，它执行main方法，这个线程称为程序的主线程，任何Java程序都至少有一个线程，即主线程。

 主线程的特殊之处在于：

• 它是产生其它线程子线程的线程；
• 通常它必须最后结束，因为它要执行其它子线程的关闭工作。

6 线程优先级

单核计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务：

• 优先级较高的线程有更多获得CPU的机会，反之亦然；
• 优先级用整数表示，取值范围是1~10，一般情况下，线程的默认
• 优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级；

 Thread类有如下3个静态常量来表示优先级：

• MAX_PRIORITY：取值为10，表示最高优先级
• MIN_PRIORITY：取值为1，表示最低优先级
• NORM_PRIORITY：取值为5，表示默认的优先级

7 线程的生命周期

 线程状态(State枚举值代表线程状态)：

• 新建状态（ NEW）： 线程刚创建, 尚未启动。Thread thread = new Thread()。

• 可运行状态（RUNNABLE）： 线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start 方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。

• 运行(running)： 线程获得 CPU 资源正在执行任务（run() 方法），此时除非此线程自动放弃 CPU 资源或者有优先级更高的线程进入，线程将一直运行到结束

• 阻塞状态（Blocked）： 线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞

• 等待（WAITING）： 进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

• 超时等待(TIMED_WAITING)： 该状态不同于WAITING，它可以在指定的时间后自行返回。

• 终止(TERMINATED)： 表示该线程已经执行完毕，如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

 线程在Running的过程中可能会遇到阻塞(Blocked)情况：

• 调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
• 调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
• 对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

8 线程创建方式

 线程创建方式：

• 实现Runnable接口，重载run()，无返回值
• 继承Thread类，复写run()
• 实现Callable接口，通过FutureTask/Future来创建有返回值的Thread线程，通过Executor执行
• 使用Executors创建ExecutorService，入参Callable或Future

1.实现Runnable接口，重载run()，无返回值，Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

public class ThreadRunnable implements Runnable {
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + ":" + i);
    }
  }
}
public class ThreadMain {
  public static void main(String[] args) throws Exception {
    ThreadRunnable threadRunnable1 = new ThreadRunnable();
    ThreadRunnable threadRunnable2 = new ThreadRunnable();
    ThreadRunnable threadRunnable3 = new ThreadRunnable();
    Thread thread1 = new Thread(threadRunnable1);
    Thread thread2 = new Thread(threadRunnable2);
    Thread thread3 = new Thread(threadRunnable3);    
    thread1.start();
    thread2.start();
    thread3.start();
  }
}
复制代码

2.继承Thread类，重写run()，通过调用Thread的start()会调用创建线程的run()，不同线程的run方法里面的代码交替执行。但由于Java不支持多继承.因此继承Thread类就代表这个子类不能继承其他类.

public class ThreadCustom extends Thread {
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread() + ":" + i);
    }
  }
}
public class ThreadTest {
  public static void main(String[] args)
  {
    ThreadCustom thread = new ThreadCustom();
    thread.start();
  }
}
复制代码

3.实现Callable接口，通过FutureTask/Future来创建有返回值的Thread线程，通过Executor执行，该方式有返回值，可以获得异步。

public class ThreadCallableCustom {
  public static void main(String[] args) throws Exception {
    FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
      public Integer call() throws Exception {
        for (int i = 0; i < 10; i++) {
          System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        return 1;
      }
    });
    Executor executor = Executors.newFixedThreadPool(1);
    ((ExecutorService) executor).submit(futureTask);
    //获得线程执行状态
    System.out.println(Thread.currentThread().getName() + ":" + futureTask.get());
  }
}
复制代码

4.使用Executors创建ExecutorService，入参Callable或Future，适用于线程池和并发

public class ThreadExecutors {
  private final String threadName;
  public ThreadExecutors(String threadName) {
    this.threadName = threadName;
  }
  private ThreadFactory createThread() {
    ThreadFactory tf = new ThreadFactory() {
      public Thread newThread(Runnable r) {
        Thread thread = new Thread();
        thread.setName(threadName);
        thread.setDaemon(true);
        try {
          sleep(1000);
        }
        catch (InterruptedException e) {
          e.printStackTrace();
        }
        return thread;
      }
    };
    return tf;
  }
  public Object runCallable(Callable callable) {
    return Executors.newSingleThreadExecutor(createThread()).submit(callable);
  }
  public Object runFunture(Runnable runnable) {
    return Executors.newSingleThreadExecutor(createThread()).submit(runnable);
  }
}
public class ThreadTest {
  public static void main(String[] args) throws Exception {
    ThreadExecutors threadExecutors = new ThreadExecutors("callableThread");
    threadExecutors.runCallable(new Callable() {
      public String call() throws Exception {
        return "success";
      }
    });
    threadExecutors.runFunture(new Runnable() {
      public void run() {
        System.out.println("execute runnable thread.");
      }
    });
  }
}
复制代码

9 Runnable接口和Callable接口区别

1）两个接口需要实现的方法名不一样，Runnable需要实现的方法为run()，Callable需要实现的方法为call()。

2）实现的方法返回值不一样，Runnable任务执行后无返回值，Callable任务执行后可以得到异步计算的结果。

3）抛出异常不一样，Runnable不可以抛出异常，Callable可以抛出异常。

10 线程安全

线程安全定义

当多个线程访问某个一类(对象或方法)时，这个类始终都能表现出正确的行为，那么这个类(对象或方法)就是线程安全的(即在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序功能正确完成)。

线程安全示例

饿汉式单例模式-线程安全

public class EagerSingleton(){
    private static final EagerSingleton instance = new EagerSingleton();
    private EagerSingleton(){};
    public static EagerSingleton getInstance(){
       return instance;
    }
}
复制代码

如何解决线程安全问题？

可以通过加锁的方式：

• 同步(synchronized)代码块：只需要将操作共享数据的代码放在synchronized
• 同步(synchronized)方法：将操作共享数据的代码抽取出来放到一个synchronized方法里面就可以了
• Lock锁：加同步锁 lock() 以及释放同步锁unlock()

11 什么是死锁、活锁？

死锁，是指两个或两个以上的进程（或线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

活锁，任务或者执行者没有被阻塞，由于某些条件没有满足，导致一直重复尝试，失败，尝试，失败。

 产生死锁的必要条件：

• 互斥条件：所谓互斥就是进程在某一时间内独占资源。
• 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
• 不剥夺条件：进程已获得资源，在末使用完之前，不能强行剥夺。
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

 死锁的解决方法：

• 撤消陷于死锁的全部进程。
• 逐个撤消陷于死锁的进程，直到死锁不存在。
• 从陷于死锁的进程中逐个强迫放弃所占用的资源，直至死锁消失。 从另外一些进程那里强行剥夺足够数量的资源分配给死锁进程，以解除死锁状态。

12 什么是悲观锁、乐观锁？

1）悲观锁

悲观锁，总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。

• 传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
• Java 里面的同步原语 synchronized 关键字的实现也是悲观锁。

2）乐观锁

乐观锁，顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。