多线程（基础）

一、前言

Ⅰ程序、进程、线程的区别

• 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
• 进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。
• 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径
  （一个进程可以有多个线程）
  （同一进程里的各个线程可以共享变量，它们之间的通信称之为线程间通信。）
  【线程是调度的基本单位，进程则是资源拥有的基本单位】

Ⅱ 并发、并行、串行

• 串行：顺序依次执行多件事情（做完一件事后再去做另一个）；

• 并发：同一时间段执行多件事情（交替做多件事情）；
  在计算机中就是一个CPU（采用时间片轮转）在同一时间段执行多个任务；
  一段代码同时被多个线程访问（一个CPU要处理多个线程的请求），所以在高并发情况下要保证线程安全，要使该段代码同步；

• 并行：同一时刻内执行多件事情（同时做多件事情）；
  在计算机中就是多个CPU同时执行多个任务；
  多个线程在同一时刻访问不同的代码块；

二、Thread类

Ⅰ、实现多线程的方式

①、实现Runnable接口，实现run()方法

②、继承Thread类，重写run()方法
Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例；

//实现Runnable接口，实现run()方法
class Thread1 implements Runnable {
    @Override
    public void run() {
        System.out.println("执行了Thread1的run方法");
    }
}

//继承Thread类，重写run()方法
class Thread2 extends Thread{
    @Override
    public void run() {
        System.out.println("执行了Thread2的run方法");
    }
}

class ThreadTest{
    public static void main(String[] args) {
        Thread1 t1=new Thread1();//接口的实现类
        Thread thread1=new Thread(t1);//还要将其包装到Thread类里面
        thread1.start();

        Thread2 thread2=new Thread2();
        thread2.start();
    }
}

③、实现Callable接口，重写call()方法
④、使用 Executors 工具类创建线程池

Ⅱ、线程相关API

void start()：启动当前线程，然后调用线程中的run方法
void run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
Thread currentThread()：静态方法，返回执行当前代码的线程
String getName()：获取当前线程的名字
void setName()：设置当前线程的名字
int getPriority()：获取当前线程优先级
void setPriority()：设置当前线程优先级
void setName()：设置当前线程的名字
void yield()：该方法作用是让当前线程放弃cpu，并等待cpu重新调度（当前线程可能再次获得cpu)。通俗点的说法是给其它线程一个机会，让大家回到同一起跑线，至于谁被cpu选中，看个人造化。
void join()：在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去
void stop()：过时方法。当执行此方法时，强制结束当前线程。
void sleep(long millitime)：线程休眠一段时间
boolean isAlive()：判断当前线程是否存活

---

wait()：，当前线程就进入等待状态，并释放同步监视器，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，然后进入阻塞状态（同步阻塞，锁池）；
wait(long time)：，当前线程就进入等待状态，并释放同步监视器，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者指定的时间过完，然后进入阻塞状态（同步阻塞，锁池）；
notify()：随机唤醒在此对象监视器上等待的一个线程
notifyAll()：唤醒在此对象监视器上等待的所有线程

• wait( )，notify( )，notifyAll( )都不属于Thread类，而是属于Object基础类。

• 当需要调用以上的方法的时候，一定要对竞争资源进行加锁，一般是放到synchronized(obj)代码中。如果不加锁的话，则会报IllegalMonitorStateException 异常。

sleep()与wait()的区别
  sleep() 方法是线程类（Thread）的静态方法，使调用线程进入睡眠状态，休眠结束后线程进入就绪状态 ;
wait()方法是Object类的方法，当线程执行到wait方法，进入到和该对象相关的等待池，同时释放对象的机锁（使得其他线程能够访问），需要通过notify，notifyAll方法唤醒线程。
sleep() 和 wait() 的区别就是 调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁

三、线程的状态（生命周期）

线程的状态分为操作系统层面和Java层面：

Ⅰ、操作系统层面（5种）

操作系统层面线程有5种状态：

1、新建状态(New)：新创建了一个线程对象。

2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

阻塞的情况分三种：

• 等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠**其他线程调用notify()或notifyAll()**方法才能被唤醒，
• 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
• 其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
  【后面两种情况不会释放锁】

5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

锁池
  假设线程A已经拥有了某个对象的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者代码块), 由于B、C线程在进入对象的synchronized方法(或者块)之前必须先获得该对象锁的拥有权，而该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，就会进入该对象的锁池，等待锁的释放。

等待池
  假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
【当等待池中的线程被唤醒后进入锁池中，才有资格去竞争获取锁】
相关方法：
notifyAll()：会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会
notify()：只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会

Ⅱ、Java层面（6种）

java中线程的状态有6种

1、NEW：初始状态，线程被构建，还没有调用 start 方法之前;

2、RUNNABLE：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行状态” ；调用了start()方法后该线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready），就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3、BLOCKED：阻塞状态，一个线程发起I/O请求或者申请一个由其他线程持有的synchronized代码块时，相应的线程会处于该状态。当阻塞式I/O操作完成后，或者线程获得了其申请的资源，该线程的状态又可以转换为RUNNABLE。

• 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，JVM会把该线程置为阻塞状态，并把该线程放入“锁池”中，直到获取到锁；
• 其他阻塞：运行的线程发出了I/O请求时，JVM会把该线程置为阻塞状态。

BLOCKED状态只有在synchronized代码块或者synchronized方法里面才可能会出现

4、WAITING：等待状态，没有时间限制的等待，需要等待其他线程做出一些特定动作（唤醒或中断）。线程执行wait()、join()、LockSupport.park()等方法后进入该状态；

5）TIMED_WAITING：超时等待状态，有时间限制的等待，它可以在指定的时间后自行返回，返回后进入运行（就绪）状态。线程执行 Thread.sleep(long)、wait(long)、join(long)、LockSupport.park(long)、LockSupport.parkNanos(long)、LockSupport.parkUntil(long)等方法后进入该状态；

6、TERMINATED：终止状态，表示当前线程执行结束，run方法执行完毕或执行过程中存在异常而终止。

注意点：

• 通过wait()方法进入等待池的线程，会释放锁，要通过其他对象调用notify()或notifyAll()方法唤醒，进入锁池去竞争获取锁的机会，才能再次变成RUNNABLE状态
• 通过wait(time)方法进入等待池的线程，会释放锁，如果等待指定时间后还没有收到通知就会超时返回，不需要被唤醒，自动醒，但在超时时间内还是需要通过外界才能被唤醒。
• 进入等待池的线程，在此之前一定获取到过锁，因某种原因放弃了锁，从而变成等待状态，等待结束后进入锁池阻塞，争夺锁后再进入运行状态
• 调用sleep()方法不会释放锁，结束后直接进入RUNNABLE状态
• wait()一定要使用sycronized进行同步，否则会报“java.lang.IllegalMonitorStateException”异常。这是因为wait方法会释放对象锁，而此时因为没有用sycronized同步，就没有锁，就会报异常。
• 以线程对象为wait方法的调用者，该线程对象运行完后，等待该线程对象的线程会自动被唤醒；

（懒得画了，找了张）

在代码中测试这几种状态：

class TestThreadState {
//测试线程状态：NEW RUNNABLE BLOCKED WAITING TIMED-WAITING TERMINATED
    public static void main(String args[]) throws InterruptedException {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t1 run方法开始执行,state:" + Thread.currentThread().getState());
                synchronized (object) {
                    System.out.println("t1 gutted lock,state:"+Thread.currentThread().getState());
                    try {
                        System.out.println("t1 begin wait");
                        object.wait();
                        System.out.println("t1 get notify from t2,"+"t1 state:" + Thread.currentThread().getState());

                    } catch (Exception e) {
                    }
                }
                System.out.println("t1 run 方法执行结束");
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t2 run方法开始执行,state:" + Thread.currentThread().getState());
                synchronized (object) {
                    System.out.println("t2 gutted lock,state:"+Thread.currentThread().getState());
                    try {
                        System.out.println("t2 begin sleep");
                        Thread.sleep(3000);
                        System.out.println("t2 to notify");
                        object.notify();
                        System.out.println("t2 begin sleep");
                        Thread.sleep(3000);
                    } catch (Exception e) {
                    }
                }
                System.out.println("t2 run 方法执行结束");
            }
        }, "t2");

        //test state
        System.out.println("t1创建完成 state:" + t1.getState());
        System.out.println("t2创建完成 state:" + t2.getState());
        t1.start();
        Thread.sleep(2000);
        t2.start();
        Thread.sleep(2000);
        while(true) {
            System.out.println("t 1 state:" + t1.getState());
            System.out.println("t 2 state:" + t2.getState());
            Thread.sleep(2000);
        }
    }
}

运行结果：

t1先获得锁，并调用wait阻塞线程和放弃锁，此时状态为：WAITING。
t2获取锁成功，并睡眠3s，此时状态为：TIMED_WAITING。
t2睡眠结束后调用notify唤醒t1，此时t2继续睡眠，状态为：TIMED_WAITING。
t1收到notify信息后，尝试获取锁，但由于此时t2还在睡眠没有释放锁，因此t1被阻塞，状态为BlOCKED。
t2睡眠结束，释放锁，t1获得锁，状态为RUNNABLE。
最终t1、t2运行完毕，处在TERMINATED状态。

线程的通信

四、线程安全与同步

Ⅰ、概念

• 线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。如果一段代码可以保证多个线程访问的时候正确操作共享数据，那么它是线程安全的。
• 同步：是指在多线程并发访问共享数据时，保证共享数据在同一时刻只被一个线程使用，是保证线程安全的一种方案。

线程安全在三个方面体现

• 原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；

• 可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；

• 有序性：即程序执行的顺序按照代码的先后顺序执行。（happens-before原则）

Ⅱ、如何保证线程安全？

1、互斥同步（阻塞同步）

  互斥是实现同步的一种手段，临界区、互斥量和信号量都是主要的互斥实现方式。因此，在这4个字里面，互斥是因，同步是果；互斥是方法，同步是目的。
  在java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码质量，这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。
  此外，ReentrantLock也是通过互斥来实现同步。在基本用法上，ReentrantLock与synchronized很相似，他们都具备一样的线程重入特性。
  互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也成为阻塞同步。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确地同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁。

实现方式：

（1）synchronized关键字

①synchronized块（同步代码块）

synchronized（同步监视器）{
//需要被同步的代码
}

同步监视器（俗称：锁）：任何一个的对象都可以充当锁，一次只有一个线程能访问。
②synchronized方法（同步方法）

synchronized public void method() {
        //方法体
}

将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。

• 对于runnable接口实现多线程，只需要将同步方法用synchronized修饰。
• 而对于继承自Thread方式，需要将同步方法用static和synchronized修饰，因为对象不唯一（锁不唯一）。
• 2.非静态的同步方法，同步监视器是this，静态的同步方法，同步监视器是当前类本身。

（2）ReentrantLock（可重入锁）

ReentrantLock继承自Lock接口，表示可重入锁（synchronized也是属于可重入锁）

同一个线程如果首次获取到该锁资源，则它就有权力再次获取到该锁（在没有释放锁之前），这就是锁的重入！

与synchronized相比（在获取锁的过程中）具有如下特点：

• 可中断：synchronized只能等待同步代码块执行结束，不可以中断，而reentrantlock可以调用线程的interrupt方法来中断等待，继续执行下面的代码。
• 可以设置超时时间：调用lock.trylock()，如果没有设置等待时间的话，没获取到锁，将返回false
• 可以设置为公平锁：公平锁其实是为了解决饥饿问题，当一个线程由于优先级太低的时候，就可能没有办法获取到时间片
• 可以支持多个变量：类似于调用wait方法时，不满足条件的线程进入waitset队列等待CPU随机调度，支持多个变量表示支持多个类似自定义waitset，这样就可以指定对象来唤醒了。

基本语法：

private static ReentrantLock reentrantLock = new ReentrantLock();//定义锁
reentrantLock.lock();//获取锁：相当于 ->    ”synchronized(reentrantLock){“
try{
	//临界区
}finally{
	reentrantLock.unlock();//释放锁，相当于synchronized的结束括号；     ”}“
}

有关ReentrantLock 的相关使用：ReentrantLock基础

2、非阻塞同步

  随着硬件指令集的发展，出现了基于冲突检测的乐观并发策略：就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采用其他的补偿措施。（最常见的补偿错误就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。

实现方式：

（1）CAS

  CAS（CompareAndSwap,先比较再交换）指令需要有3个操作数，分别是内存地址（在java中理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，当且仅当V处的值符合旧预期值A时，处理器用B更新V处的值，否则它就不执行更新，但是无论是否更新了V处的值，都会返回V的旧值，上述的处理过程是一个原子操作。
CAS缺点：
  ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。
  ABA问题的解决思路就是使用版本号。在变量前面追加版本号，每次变量更新的时候把版本号加一，那么A-B-A就变成了1A-2B-3C。JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的；compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

3、无同步方案

要保证线程安全，并不是一定就要进行同步，如果一个方法本来就不涉及共享数据，那它自然就无需任何同步操作去保证正确性。

（1）可重入代码

可重入代码（ReentrantCode），可以在代码执行的任何时刻中断它，转而去执行另外一段代码，而在控制权返回后，原来的程序不会出现任何错误。
所有的可重入代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。

特点：不涉及共享数据，不依赖存储在堆上的数据和公用的系统资源、用到的状态量都是由参数中传入、不调用非可重入的方法等。

（2）线程本地存储

如果一段代码中所需的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内。这样无需同步也能保证线程之间不出现数据的争用问题。

ThreadLocal类是用来保证线程内部的共享变量，在多线程环境下，各个线程之间的变量互相隔离、相互独立。在线程中，可以通过get()/set()方法来访问变量。ThreadLocal实例通常来说都是private static类型的，它们希望将状态与线程进行关联。这种变量在线程的生命周期内起作用，可以减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。

ThreadLocal常用方法介绍
get()方法：获取与当前线程关联的ThreadLocal值。
set(T value)方法：设置与当前线程关联的ThreadLocal值。
remove()方法：将与当前线程关联的ThreadLocal值删除。
initialValue()方法：设置与当前线程关联的ThreadLocal初始值。

五、用户线程与守护线程

  用户线程即我们手动创建的线程，而守护线程是一种通用服务的线程，作为用户线程的。
两者区别：当所有非守护线程停止时,守护线程才停止(注意:守护线程不是立即停止,中间有个缓冲时间）

守护线程的应用：

• QQ等等聊天软件,主程序是非守护线程,而所有的聊天窗口是守护线程，当在聊天的过程中,直接关闭聊天应用程序时,聊天窗口也会随之关闭。
• JVM中，GC（垃圾回收线程）线程是守护线程,作用就是当所有用户自定义线以及主线程执行完毕后，GC线程才停止。

相关方法：
setDaemon(true)：将线程设置为守护线程。
isDaemon()：判断是否为守护线程。

注意事项：

• setDaemon(true)必须在start()方法前执行，否则会抛出 IllegalThreadStateException 异常
• 在守护线程中产生的新线程也是守护线程
• 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
• 守护 (Daemon) 线程中不能依靠 finally 块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，所以守护 (Daemon) 线程中的 finally 语句块可能无法被执行。

六、死锁

Ⅰ、概念

  死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

Ⅱ、死锁的四个必要条件

• 互斥条件：线程(进程)对于所分配到的资源具有排它性，即一个资源只能被一个线程(进程)占用，直到被该线程(进程)释放。
• 请求与保持条件：一个线程(进程)因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
• 不剥夺条件：线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
• 循环等待条件：当发生死锁时，所等待的线程(进程)必定会形成一个环路（类似于死循环），造成永久阻塞。

Ⅲ、避免死锁策略

只要破坏产生死锁的四个条件中的其中一个就可以避免产生死锁：

• 破坏互斥条件：这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。

破坏请求与保持条件：要求线程一次性申请所有的资源，若资源不能够满足，就阻塞该进程，阻塞期间没有占用任何资源。

破坏不剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。

破坏循环等待条件：采用有序分配资源的策略来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

七、乐观锁与悲观锁

悲观锁

  悲观锁是一种悲观思想，它总认为最坏的情况可能会出现，每次操作数据前它认为数据很可能会被其他人所修改，所以悲观锁在持有数据的时候总会把资源或者数据锁住，这样其他线程想要请求这个资源的时候就会阻塞，直到等到悲观锁把资源释放为止。
  传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是**在做操作之前先上锁。**悲观锁的实现往往依靠数据库本身的锁功能实现。
  Java 中的 Synchronized 和 ReentrantLock 等独占锁(排他锁)也是一种悲观锁思想的实现，因为 Synchronzied 和 ReetrantLock 不管是否持有资源，它都会尝试去加锁。

乐观锁

  乐观锁的思想与悲观锁的思想相反，它总认为资源和数据不会被别人所修改，所以读取不会上锁，但是乐观锁在进行写入操作的时候会判断当前数据是否被修改过。
乐观锁的实现方案一般是CAS算法实现 。
乐观锁多适用于多读的应用类型，这样可以提高吞吐量。
更多请看：乐观锁与悲观锁之类的博客

八、volatile

volatile关键字可以保证内存可见性和有序性，但不能保证原子性，禁止指令重排。

♦指令重排是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序

♦内存可见性（Memory Visibility）：所有线程都能看到共享内存的最新状态。（也就是说，volatile关键字修饰的变量看到的随时是自己的最新值。线程1中对变量v的最新修改，对线程2是可见的）

Java中的原子性操作包括：

• 基本类型的读取和赋值操作，且赋值必须是数字赋值给变量，变量之间的相互赋值不是原子性操作。（例如 a=1是原子性操作，但是a++和a +=1就不是原子性操作。）
• 所有引用reference的赋值操作
• java.concurrent.Atomic.* 包中所有类的一切操作