java多线程

java多线程是一个比较热门的话题，方方面面都会用到它，今天我想说说我浅薄的认知
一.并发，并行
1.并发：并发指两个或者多个事物在同一个时间段内发生，交替执行相当于一个人吃两个馒头
2.并行：并行指两个或多个事物在同一时刻发生，同时执行相当于两个人吃两个馒头
二.进程，线程
1.进程指一个内存中运行的应用程序，一个应用程序也可以有很多进程
2.线程是进程中的执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，也可以有多个线程，这个应用程序也被称为多线程程序

CPU：即中央处理器，对数据进行计算，指挥电脑中的软硬件干活。

三.线程调度
（1）分时调度：所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间
（2）抢占式调度：抢先让优先级高的线程使用cpu，若线程优先级相同，那么会随机选择一个线程（线程随机性）java使用的为抢占式调度

四.主线程
主线程即为执行主方法（main）方法的线程
（1）单线程程序：java程序只有一个线程，执行从main开始，从上到下依次进行
（2）jvm执行main方法，main方法会进入到栈内存中，jvm会找操作系统开辟一条main方法通往cpu的执行路径，cpu就可以通过这个路径来执行main方法，这个路径称为main线程，也就主线程

五.创建线程类
jvm允许应用程序并发的运行多个执行程序
第一种方式：创建Thread类的子类，想要实现多线程，必须继承，
步骤：
（1）创建一个Thread的子类，并重写Thread的run方法，设置线程任务
（2）创建Thread类的子类对象
（3）调用Thread类的方法start()，开启新的线程，执行run方法
（4）结果是两个线程并发的运行：当前线程（main线程）和另外一个线程（执行run方法的创建的新线程）
start方法一个线程只能调用一次，多次调用非法。

六.Thread类中的常用方法
（1）使用Thread中的方法 String getName()返回线程名称
（2）获取到当前正在执行的线程static Thread currentThread()
可以先获取到当前正在执行的线程，然后使用获得线程名称的方法String getName()获取线程名称：
System.out.println(Thread.currentThread.getName());
注意：main线程不能使用getName的方法获取到线程名称，因为main方法所属并没有继承Thread类，不可以使用Thread类的方法
（3）设置线程名称，①使用Thread类中方法setName（String name）。②创建一个带参的构造方法，参数传递想取得线程名字，调用父类构造方法，把线程名称传递给父类，让父类给线程取一个名字。
（4）public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
（5）public void run() :此线程要执行的任务在此处定义代码。
（6）public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

七.创建多线程的第二种方式
1.创建一个实现类，实现Runable接口重写里面的run方法
2.接着在主方法里面创建实现类的对象，创建Thread对象，构造方法中传入Runable的实现类，调用start方法开启

八.Thread和Runable的区别
即实现Runable接口创建多线程的好处
1.避免了单继承的局限性：一个类只能继承一个类，类继承了Thread类就不能继承其他类，实现了Runable接口还可以继承其他类，实现其他接口
2.增强了程序的扩展性，降低了程序的耦合性
实现了Runable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

九.匿名内部类实现线程的创建
（1）匿名内部类的作用：简化代码，把子类继承父类，重写父类方法，创建子类对象一步完成
（2）把实现类实现接口，重写接口中的方法，创建实现类对象一步完成
其最终产物：子类/实现类对象，而这个类没有名字
格式：new 父类/接口{重写父类/接口 方法}
这个地方可用lambda公式，方法引用进行简化

十.线程安全
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的，反之就是线程不安全的

十一.线程同步（解决线程安全问题）
（1）同步代码块（第一种方式）
格式：
synchronize（锁对象） { 可能会出现安全问题的代码（即访问了共享数据的代码）}
注意：①.同步代码快的锁对象可以使用任意对象
②.必须保证多个线程使用的是锁对象是同一个
③锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行

（2）同步方法（第二种方式）
①把访问了共享数据的代码抽取出来，放到一个方法中
②在方法上添加 synchronized修饰符
格式：
修饰符 synchronized 返回值类型 方法名（参数列表） {
可能会出现线程安全问题的代码（访问共享数据）
}
注意：同步是高开销的操作，因此尽量减少同步的内容。通常没必要同步整个方法，使用同步代码块即可

（3）lock锁（第三种方式）、
*lock提供了比使用synchronized方法和语句可获得更广泛的锁定操作
*lock接口中的方法
–void lock（）获取锁
–void unlock（）释放锁
**使用步骤 （实现Reentrantlock implement lock 接口
①在成员位置创建一个Reentrantlock 对象
②在可能会出现安全问题的代码前调用lock接口的方法lock（）获取锁
③在可能会出现安全问题的代码前调用lock接口的方法unlock（）释放锁

注意：①synchronized是关键字，而lock是一个接口，用到它的实现类Reentrantlock
②Synchronized在线程发生异常时会自动释放锁，因此不会发生异常死锁。Lock异常时不会自动 释放锁，所以需要在finally中实现释放锁。
④Lock是可以中断锁，Synchronized是非中断锁，必须等待线程执行完成释放锁。
⑤Lock可以使用读锁提高多线程读效率。
⑥使用synchronized时，一个线程迟迟不释放锁，另一个等待的线程会一直阻塞下去。但lock锁等待的线程迟迟没拿到锁不会一直等待下去。

十二.线程状态
1.新建状态(New)：
当用new操作符创建一个线程时， 例如new Thread®，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码
2.就绪状态(Runnable)
一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
3.运行状态(Running)
当线程抢到cpu的执行权后就进入运行状态
4. 阻塞状态(Blocked)
线程运行过程中，可能由于各种原因进入阻塞状态:
*线程通过调用sleep方法进入睡眠状态
*线程试图得到一个锁，而该锁正被其他线程持有；
5. 死亡状态(Dead)
有两个原因会导致线程死亡：
① run方法正常退出而自然死亡，
②一个未捕获的异常终止了run方法而使线程猝死

十三.等待唤醒机制（线程之间的通信合作）
进入到TimeWaiting(计时等待)有两种方式
1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

唤醒的方法:
     void notify() 唤醒在此对象监视器上等待的单个线程。
     void notifyAll() 唤醒在此对象监视器上等待的所有线程。

包子案例说明等待唤醒机制

public class WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象,保证唯一
        Object obj = new Object();
        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客1告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了,顾客1开吃!");
                        System.out.println("---------------------------------------");
                    }
                }
            }
        }.start();

        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客2告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了,顾客2开吃!");
                        System.out.println("---------------------------------------");
                    }
                }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //一直做包子
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);//花5秒钟做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
                        //做好包子之后,调用notify方法,唤醒顾客吃包子
                        //obj.notify();//如果有多个等待线程,随机唤醒一个
                        obj.notifyAll();//唤醒所有等待的线程
                    }
                }
            }
        }.start();
    }
}

十四.线程池
jdk1.5版本后内置了线程池，我们可以直接使用。

（1）java.uti.Concurrent.Exception：线程池类，用来生成线程池
Executors类的静态方法
static ExecutorService new FixedThreadPool（int nThread）
创建一个课重复使用固定数量的线程池
参数：int nThread 创建线程池中包含的线程数量
返回创建的线程池对象
（2）调用 ExecutorService 中的方法submit，从线程池中获取线程对象，传递线程任务，开启线程执行run方法。submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
（3）使用线程池中线程对象的步骤：

1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池，使用 ExecutorService中shutdown()方法(一般不做)