黑马程序员—Java基础—多线程

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

目录：一、多线程的概念 二、线程安全问题 三、线程间通信

一、多线程的概念

进程：正在进行中的程序（直译）。
    线程：进程中一个负责程序执行的控制单元（执行路径）。

    P.S.
    1、一个进程中可以有多个执行路径，称之为多线程。
    2、一个进程中至少要有一个线程。
    3、开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

    多线程的好处：解决了多部分代码同时运行的问题。
    多线程的弊端：线程太多，会导致效率的降低。
    其实，多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。CPU的切换是需要花费时间的，从而导致了效率的降低。

    JVM启动时启动了多条线程，至少有两个线程可以分析的出来：
    1. 执行main函数的线程，该线程的任务代码都定义在main函数中。
    2. 负责垃圾回收的线程。

 P.S.
    System类的gc方法告诉垃圾回收器调用finalize方法，但不一定立即执行。

 

  1. 定义一个类继承Thread类。
    2. 覆盖Thread类中的run方法。
    3. 直接创建Thread的子类对象创建线程。
    4. 调用start方法开启线程并调用线程的任务run方法执行。

  创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

    jvm创建的主线程的任务都定义在了主函数中。而自定义的线程，它的任务在哪儿呢？
    Thread类用于描述线程，线程是需要任务的。所以Thread类也有对任务的描述。这个任务就是通过Thread类中的run方法来体现。也就是说，run方法就是封装自定义线程运行任务的函数，run方法中定义的就是线程要运行的任务代码。

    开启线程是为了运行指定代码，所以只有继承Thread类，并复写run方法，将运行的代码定义在run方法中即可。

 P.S.
    1、可以通过Thread的getName方法获取线程的名称，名称格式：Thread-编号（从0开始）。
    2、Thread在创建的时候，该Thread就已经命名了。

 

 1. 定义类实现Runnable接口。
    2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
    3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
    4. 调用线程对象的start方法开启线程。

    实现Runnable接口的好处：
    1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
    2. 避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

 

二、线程安全问题

线程安全问题产生的原因：
    1. 多个线程在操作共享的数据。
    2. 操作共享数据的线程代码有多条。
    当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

线程安全问题的解决方案
    思路：
    就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

    在java中，用同步代码块就可以解决这个问题。
    同步代码块的格式：
    synchronized(对象){
           需要被同步的代码;
    } 
    同步的好处：解决了线程的安全问题。
    同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
    同步的前提：必须有多个线程并使用同一个锁。

 

 安全问题的另一种解决方案：同步代码块

    格式：在函数上加上synchronized修饰符即可。

  P.S.

    同步函数和同步代码块的区别：
    1. 同步函数的锁是固定的this。
    2. 同步代码块的锁是任意的对象。
    建议使用同步代码块。

 

    由于同步函数的锁是固定的this，同步代码块的锁是任意的对象，那么如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

 静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

 

 P.S.
    饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况。

 P.S.

    懒汉式存在安全问题，可以使用同步函数解决。

    但若直接使用同步函数，则效率较低，因为每次都需要判断。

  原因在于任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则再判断是否能够获取锁。

    1.如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。

2. 如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。

 

三、线程间通信

线程间通信涉及的方法

多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。

    等待/唤醒机制涉及的方法：
    1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
    2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
    3. notifyAll()：唤醒线程池中的所有线程。

    P.S.
    1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。
    2、必须要明确到底操作的是哪个锁上的线程！
    3、wait和sleep区别？
         1）wait可以指定时间也可以不指定。sleep必须指定时间。
         2）在同步中时，对CPU的执行权和锁的处理不同。
         wait：释放执行权，释放锁。
         sleep：释放执行权，不释放锁。

    为什么操作线程的方法wait、notify、notifyAll定义在了object类中，因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定在object类中。

 P.S.

   while判断标记+notify会导致死锁的示例：

    如果将上面的代码中的if判断标记修改成wile判断标记，就会出现死锁的现象，前2步与原来是一致的。第3步如下：

3. 线程Thread-0获取到CPU执行权及锁，通过了while语句判断，直接生产烤鸭3299，将flag设置为true。然后又唤醒线程Thread-1获取到CPU执行权及锁，没有通过while语句判断，阻塞。线程Thread-0又获取到CPU执行权及锁，通不过while语句判断，也阻塞，此时Thread-0、1、2、3都阻塞，故死锁。

JDK1.5新特性

    同步代码块就是对于锁的操作是隐式的。
    JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了显示动作。

    Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。
    lock()：获取锁。
    unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。

    Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以任意锁进行组合。
    Condition接口中的await方法对应于Object中的wait方法。
    Condition接口中的signal方法对应于Object中的notify方法。
    Condition接口中的signalAll方法对应于Object中的notifyAll方法。

 

停止线程  

    怎么控制线程的任务结束呢？

任务中都会有循环结构，只要控制住循环就可以结束任务。
    控制循环通常就用定义标记来完成。

 P.S.
    也可以使用stop方法停止线程，不过已经过时，不再使用。

    但是如果线程处于了冻结状态，无法读取标记，如何结束呢？
    可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。强制动作会发生InterruptedException，一定要记得处理。