多线程

多线程

首先，什么是进程？

进程就是电脑中会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。比如QQ、微信、酷狗播放器等。

什么是线程？

进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。

那什么是多线程？提到多线程这里要说两个概念，就是串行和并行。

串行，其实是相对于单条线程来执行多个任务来说的，我们就拿下载文件来举个例子：当我们下载多个文件时，在串行中它是按照一定的顺序去进行下载的，也就是说，必须等下载完A之后才能开始下载B，它们在时间上是不可能发生重叠的。

并行：下载多个文件，开启多条线程，多个文件同时进行下载，这里是严格意义上的，在同一时刻发生的，并行在时间上是重叠的。

多线程可以提高程序的效率。

并发，并行，串行的区别：

并发是指一个处理器同时处理多个任务。
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。

串行是指程序从上往下的同步执行，即如果第一行代码执行没有结束，第二行代码就只能等待第一行执行结束后才能结束。
并发是逻辑上的同时发生，而并行是物理上的同时发生。

 一、多线程创建方式

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

三种方式比较：

    Thread: 继承方式, 不建议使用, 因为Java是单继承的，继承了Thread就没办法继承其它类了，不够灵活
    Runnable: 实现接口，比Thread类更加灵活，没有单继承的限制
    Callable: Thread和Runnable都是重写的run()方法并且没有返回值，Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行
    当线程不需要返回值时使用Runnable，需要返回值时就使用Callable，一般情况下不直接把线程体代码放到Thread类中，一般通过Thread类来启动线程
    Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现

二、线程的状态 

线程的状态可从 操作系统层面分为五种状态， 从java api层面分为六种状态。

1. 创建（new）状态: 准备好了一个多线程的对象，即执行了new Thread(); 创建完成后就需要为线程分配内存
2.就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
3.运行（running）状态: 执行run()方法
4.阻塞（blocked）状态: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
5.死亡（terminated）状态: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

1.NEW 线程对象被创建
2.Runnable 线程调用了start()方法后进入该状态，该状态包含了三种情况

    就绪状态 :等待cpu分配时间片
    运行状态:进入Runnable方法执行任务
    阻塞状态:BIO 执行阻塞式io流时的状态

3.Blocked 没获取到锁时的阻塞状态(同步锁章节会细说)
4.WAITING 调用wait()、join()等方法后的状态
5.TIMED_WAITING 调用 sleep(time)、wait(time)、join(time)等方法后的状态
6.TERMINATED 线程执行完成或抛出异常后的状态

1. start() 与 run()

start(): 启动一个线程，线程之间是没有顺序的，是按CPU分配的时间片来回切换的。

run(): 调用线程的run方法，就是普通的方法调用，虽然将代码封装到两个线程体中，可以看到线程中打印的线程名字都是main主线程，run()方法用于封装线程的代码，具体要启动一个线程来运行线程体中的代码(run()方法)还是通过start()方法来实现，调用run()方法就是一种顺序编程不是并发编程。
注：start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

2. sleep() 与 interrupt()

sleep(): 睡眠指定时间，即让程序暂停指定时间运行，时间到了会继续执行代码，如果时间未到就需要使用interrupt()来随时唤醒
interrupt(): 唤醒正在睡眠的程序，调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去

3. wait() 与 notify()

wait、notify和notifyAll方法是Object类的final native方法。所以这些方法不能被子类重写，Object类是所有类的超类，因此在程序中可以通过this或者super来调用this.wait(), super.wait()

    wait(): 导致线程进入等待阻塞状态，会一直等待直到它被其他线程通过notify()或者notifyAll唤醒。该方法只能在同步方法中调用。如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。wait(long timeout): 时间到了自动执行，类似于sleep(long millis)
    notify(): 该方法只能在同步方法或同步块内部调用， 随机选择一个(注意：只会通知一个)在该对象上调用wait方法的线程，解除其阻塞状态
    notifyAll(): 唤醒所有的wait对象

注意：

    Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部
    让哪个对象等待wait就去通知notify哪个对象，要操作同一个对象

4.interrupt()与interrupted()

interrupt()：打断线程，将中断状态修改为true

interrupted():如当前线程处于中断状态返回true， 不打断线程，获取线程的中断状态，并将中断状态设置为false

sleep与wait的区别

• sleep在Thread类中，wait在Object类中
• sleep不会释放锁，wait会释放锁
• sleep使用interrupt()来唤醒，wait需要notify或者notifyAll来通知

三、线程安全

线程安全问题是指，多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。

解决方案：

方式一：同步代码块

使用同步监视器（锁）
Synchronized（同步监视器）{
//需要被同步的代码
}
说明：

    操作共享数据的代码（所有线程共享的数据的操作的代码）（视作卫生间区域（所有人共享的厕所）），即为需要共享的代码（同步代码块，在同步代码块中，相当于是一个单线程，效率低）
    共享数据：多个线程共同操作的数据，比如公共厕所就类比共享数据
    同步监视器（俗称：锁）：任何一个的对象都可以充当锁。（但是为了可读性一般设置英文成lock）当锁住以后只能有一个线程能进去（要求:多个线程必须要共用同一把锁，比如火车上的厕所，同一个标志表示有人）

Runable天生共享锁，而Thread中需要用static对象或者this关键字或者当前类（window。class）来充当唯一锁

方式二：同步方法
使用同步方法，对方法进行synchronized关键字修饰
将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。
对于runnable接口实现多线程，只需要将同步方法用synchronized修饰
而对于继承自Thread方式，需要将同步方法用static和synchronized修饰，因为对象不唯一（锁不唯一）

总结：1.同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。
2.非静态的同步方法，同步监视器是this
静态的同步方法，同步监视器是当前类本身。继承自Thread.class

方式三：lock（）锁方法

总结：Synchronized与lock的异同？

相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的代码逻辑以后，自动的释放同步监视器
lock需要手动的启动同步（lock（）），同时结束同步也需要手动的实现（unlock（））

优先使用顺序：
LOCK>同步代码块>同步方法

判断线程是否有安全问题，以及如何解决：

1.先判断是否多线程
2.再判断是否有共享数据
3.是否并发的对共享数据进行操作
4.选择上述三种方法解决线程安全问题

线程的死锁问题：

线程死锁的理解：僵持，谁都不放手，一双筷子，我一只你一只，都等对方放手（死锁，两者都进入阻塞，谁都吃不了饭，进行不了下面吃饭的操作）
出现死锁以后，不会出现提示，只是所有线程都处于阻塞状态，无法继续

死锁的解决办法：

1.减少同步共享变量
2.采用专门的算法，多个线程之间规定先后执行的顺序，规避死锁问题
3.减少锁的嵌套。