面试必备基础知识 —并发

进程 线程

进程 对应一个程序，每个程序对应一定的内存地址空间，并且只能使用它自己的内存空间，各个进程间互不干扰。并且进程保存了程序每个时刻的运行状态，这样就为进程切换提供了可能。当进程暂停时，它会保存当前进程的状态，在下一次重新切换回来时，便根据之前保存的状态进行恢复，然后继续执行。（这就是并发）

虽然 并发 在宏观上有多个任务在执行，但事实上，任何一个具体的时刻，只有一个任务在占用CPU资源（对于单核CPU来说）。

一个进程包含多 线程 ，每个线程负责一个独立的子任务，这些线程是共同享有进程占有的资源和地址空间的。

进程是操作系统进行 资源分配 的基本单位，而线程是操作系统进行 调度 的基本单位。

创建线程

实现 Runnable 接口

需要实现接口中的 run() 方法。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

通过实现Runnable接口，我们定义了一个子任务，然后将子任务交由Thread去执行。这种方式必须将Runnable作为Thread类的参数，然后通过Thread的 start 方法来创建一个新线程来执行该子任务。

public class Test {
    public static void main(String[] args)  {
    	System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
class MyRunnable implements Runnable{  
    public MyRunnable() {
    }
    @Override
    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}

继承 Thread 类

同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runnable 接口。

public
class Thread implements Runnable {
	……
}

当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。

实现 Callable 接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

实现接口 与 继承Thread类相比，实现接口会更好一些，因为：

• Java不支持多重继承，因此继承了Thread 类就无法继承其它类，但是可以实现多个接口。
• 类可能只要求执行就行，继承整个 Thread 类开销多大。

线程状态

• 创建(new)：创建后尚未启动。
• 就绪(runnable)：线程创建之后不会立即进入就绪状态。只有当线程运行需要的条件满足，才进入就绪状态。
• 运行(running)：获取CPU执行时间，线程进入运行状态。
• 阻塞(blocked) time waiting ，waiting
• 消亡(dead)：突然中断，或子任务执行完毕，线程就会被消亡。

Thread类中常用的方法

start() 方法：用来启动一个线程。当调用start()方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

run() 方法：该方法不需要用户来调用，当通过start() 方法启动一个线程之后，当线程获得了 CPU执行时间，便进入run方法体去执行具体的任务。（继承Thread类必须重写run方法，在run方法中定义具体要执行的任务）

sleep() 方法：相当于让线程睡眠，交出CPU，让CPU去执行其它的任务。（相当于让线程进入阻塞状态）

sleep(long millis)     //参数为毫秒 
sleep(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

sleep()方法不会释放锁，也就是说，如果当前线程持有对某个对象的锁，则即使调用sleep方法，其它线程也无法访问该对象。

sleep()方法可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出其它的异常同样也需要本地进行处理。

public void run() {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

yield() 方法：调用静态方法 Thread.yield() 声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是给线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程有获取CPU执行时间的机会。

join() 方法：在线程中调用另一个线程的 join()方法，会将当前线程 挂起，而不是忙等待，直到目标线程结束。

currentThread() 方法：Thread类中的静态方法，用来获取当前线程。

中断

一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。

interrupt() 方法：通过调用一个线程的 interrupt() 方法来 中断 该线程。如果该线程处于阻塞状态，那么回抛出 InterruptedException ，从而提前结束该线程。但是不能中断 I/O阻塞 和 synchronized 锁阻塞。

如果一个线程的 run()方法执行一个无限循环，并且没有执行 sleep() 等会抛出InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。（也就是说，直接调用interrupt()方法，不能中断运行中的线程）

但是调用 interrupt() 方法会设置线程的 中断标记，此时调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。

守护线程

Daemon：守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀死所有的守护线程。

main()方法 属于非守护线程。

在线程启动之前，使用 setDaemon() 方法可以将一个线程设置为守护线程。

守护线程 与 用户线程

区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。
eg：如果在main线程中创建一个守护线程，当main方法运行完毕后，守护线程也会随着消亡。而用户线程不会，用户线程会一直运行直到其运行完毕。
在JVM 中，垃圾收集器线程就是守护线程。

Thread类中方法调用引起的线程状态变化图：

图片来源

互斥同步

Java 提供了两种 锁机制 来控制多个线程对共享资源的互斥访问，第一个是 JVM实现的 synchronized，另一个是 JDK实现的 ReentrantLock 。

synchronized

同步一个代码块

public void func() {
    synchronized (this) {
        // ...
    }
}

它只作用于同一个对象。
当一个线程进入同步代码块时，另一个线程就必须等待。

同步一个方法

public synchronized void func () {
    // ...
}

和同步代码块一样，作用于同一个对象。

同步一个类

public class SynchronizedExample {
	// ...
}
public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

同步一个静态方法

public synchronized static void fun() {
    // ...
}

作用于整个类。

ReentrantLock

“可重入锁” ，ReentrantLock 是唯一实现了 Lock 接口的类
ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //声明为类变量
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock(); //确保释放锁，避免发生死锁
        }
    }
}

synchronized 与 ReentrantLock 比较

1. 锁的实现
   synchronized 是 JVM实现的，ReentrantLock 是JDK实现的。

2. 性能
   大致相同

3. 等待可中断
   当持有锁的线程长期不释放锁时，正在等待锁的线程可以选择放弃等待，改为处理其它的事情。
   ReentrantLock 可中断，synchronized 不可中断。

4. 公平锁
   公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
   synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以是公平的。

5. 锁绑定多个条件
   一个ReentrantLock 可以同时绑定多个 Condition 对象。

使用选择

除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。
因为synchronized 是 JVM 实现的一种锁机制， JVM 原生地支持它。并且使用synchronized 不用担心没有释放锁而导致死锁的问题，因为 JVM 会确保锁的释放。

Java 内存模型

Java内存模型试图屏蔽各个硬件和操作系统的内存访问差异，以实现让Java程序在各个平台下都能达到一致的内存访问效果。

CPU 上的寄存器的读写的速度比内存块几个数量级，为了解决这种速度矛盾，在它们之间加入了 高速缓存。

加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。

图片来源

所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。

线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。

• Load：把 read 得到的值放入工作内存的变量副本中。
• Store：把工作内存的一个变量的值传送到主内存中。

内存模型的三大特性

1. 原子性

   在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

x = 10;        // 原子性操作
y = x;         // 不是
x++;           // 不是
x = x + 1;     // 不是

Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过 synchronized 和 Lock 来实现。由于 synchronized 和 Lock 能够保证任一时刻只有一个线程执行该代码块，那么就不会存在原子性问题了，从而保证了原子性。

2. 可见性

   可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。Java内存模型是通过在变量修改后将值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。

   实现可见性的三种主要方式：

   • volatile：当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主内存，当有其它线程需要读取时，它会去内存中读取新值。
   • synchronized：对一个变量执行 unlock 操作之前，必须把变量同步回主内存。
   • final：被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生错误，那么其它线程就能看见 final 字段的值。

3. 有序性

   有序性是指，在本线程内观察，所有操作都是有序的。在一个线程中观察另一个线程，所有操作都是无序的，无序是因为发生了 指令重排序。

   在 Java 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，但会影响到多线程并发执行的正确性。

   volatile 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
   也可以通过 synchronized 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。

   Java内存模型还具备了一些先天的 “有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。让一个操作无需控制就能先于另一个操作完成。

   先行发生原则

   • 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作。
   • 管程锁定规则：一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
   • volatile变量规则：对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
   • 线程启动规则：Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
   • 线程中断规则：对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
   • 线程终结规则：线程中所有的操作都先行发生于线程的终止检测。
   • 对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。
   • 传递性：如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。

线程间协作

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行 协调 。

wait() notify() notifyAll()

wait()、notify()和notifyAll()方法是本地方法，并且为 final 方法，无法被重写。

它们都属于 Object 的一部分，而不属于 Thread。

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其它线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

只能在同步方法或者同步代码块中使用，否则会在运行时抛出 IllegalMonitorStateException

使用 wait 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

wait() 和sleep() 的区别

• wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
• wait() 会释放锁，sleep() 不会。

await() signal() signalAll()

java.util.concurrent 类库中提供了 Condition 类，Condition 是在 java1.5中才出现的，它用来替代传统的 Object 的 wait() 、notify() 实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()（可以指定等待的条件）、signal()这种方式实现线程间协作更加安全和高效。

Condition 是一个接口，依赖于 Lock接口，生成一个 Condition 的基本代码是 lock.newCondition()