多线程

进程：正在进行中的程序（直译）

线程：就是进程中的负责程序中的控制单元（执行路径）

一个进程中可以有多个执行路径

一个进程中至少要有一个线程

开启多个线程是为了同时运行多部分代码

每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务

好处：可以使多个程序同时执行

弊端：效率低

其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的

JVM启动时就启动了多个线程，至少有两个线程可以分析的出来：

1.执行main函数的线程

        该线程的任务代码都定义在main函数中

2.负责垃圾回收的线程

         每个对象都具备着被回收的方法finalize()

gc() ：垃圾回收器

如何创建一个线程呢？

创建线程方式一：继承Thread类

步骤：

  1.定义一个类继承Thread类

   2.覆盖Thread类中的run()方法

   3.直接创建Thread类的子类对象

    4.调用start()方法开启线程并调用线程的run方法开始执行

调用run和调用start有什么区别？

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

而运行的指定代码就是这个执行路径的任务

jvm创建的主线程的任务都定义在了主函数当中，

而自定义的线程它的任务在哪呢？

Tread类用于描述线程，线程是需要任务的，所以Tread类也有对任务的描述

这个任务就通过Thread类中的run()方法来体现，也就是说，run()方法就是封装自定义线程运行任务的函数

run()方法中定义就是线程要运行的任务代码

开启线程是为了运行指定代码，所以只有继承Thread类，并覆写run方法

将运行的代码定义在run方法中即可

可以通过Thread的getName获取线程的名称 Thread-编号（从0开始）

主线程的名字就是main

Thread.currentThread().getName() 可以获取当前正在运行的线程的名字

==========================================================================================

notify()方法：唤醒操作

CPU的执行资格：可以被cpu处理，在处理队列中排队

CPU的执行权：正在被cpu处理

创建线程的第一种方式：继承Thread类

创建线程的第二种方式：实现Runnable接口

  1.定义类实现Runnable接口

  2.覆盖接口中的run方法，将线程的任务代码封装到run方法中

  3.通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类构造函数的参数进行传递。

           为什么？ 因为线程的任务都封装在Runnable接口子类对象的run方法中

                      所以要在线程对象创建时就必须明确要运行的任务  

  4.调用线程对象的start方法开启线程

Runnable的出现仅仅是将线程的任务进行了对象的封装

实现Runnable接口的好处：

1.将线程的任务从线程的子类中分离出来，进行了单独的封装

       按照面向对象的思想将任务封装成了对象

2.避免了java单继承的局限性

所以，创建线程的第二种方式较为常用

线程安全问题产生的原因：

1.多个线程在操作共享的数据

2.操作共享数据的线程代码有多条

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

解决思路：

就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，

其他线程是不可以参与运算的，

必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算

在java中，用同步代码块就可以解决这个问题

同步代码块的格式：

synchronized (对象)

{

      需要被同步的代码；

}

同步的好处：解决了线程的安全问题

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁

同步的前提：必须有多个线程并使用同一个锁

同步函数使用的锁是this

同步函数和同步代码块的区别：
 同步函数的锁是固定的this，即当前对象

 同步代码块的锁是任意的对象

建议使用同步代码块

静态的同步函数使用的锁是 该函数所属的字节码文件对象，

可以用getClass方法获取，也可以用当前 类名.class表示

多线程下的单例

=======================================================================================

线程间的通信：

   多个线程在处理同一资源，但是任务却不同