多线程详解

一、基本概念

1、程序

　　数据结构 + 算法，主要指存放在硬盘上的可执行文件。换言之，就是编写的代码。

2、进程

　　主要指运行在内存中的可执行文件。 换言之，就是正在运行的程序，如下图所示，电脑中会有很多单独运行的程序，这些就是进程

 3、线程

      线程就是进程内部的程序流，操作系统内部支持多进程，而每个进程的内部又支持多线程。换句话说，进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。

4、串行

      相对单条线程来说的，单线程中执行多个任务。在这个线程中，执行多任务顺序是，任务A -> 任务B ->  任务C ... 必须按照顺序来。跟跑接力赛一样，第一棒跑完，第二棒才跑，然后第三棒、第四棒。

5、并行

      开启多条线程。在同一个时刻，比如任务A被同时执行，这是严格意义的时间上的重叠。跟跑接力赛一样，裁判喊123，第一棒同时出发，不差毫秒，第二棒同时接棒...（当然这是理想情况 ）。

6、并发

　  所谓并发就是指宏观并行微观串行的机制。就是肉眼看上去一个程序在同时执行，其实它在偷偷串行。

7、多线程

     多线程是采用时间片轮转法来保证多个线程的并发执行。假如时间片是沙漠里的一瓶水，有几个人，就是你喝一口，我喝一口。保证大家活着走出沙漠（类比线程执行完成）就是多线程。

二、线程的创建

1、Thread类

       java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例。
2、创建方式
（1）继承Thread类

　　定义一个类，继承Thread类并重写run方法，然后创建这个类的对象，再调用start方法。

      举个例：

public class SubThreadRun extends Thread {
 
    @Override
    public void run() {
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            System.out.println("run方法中：i = " + i); // 1 2 ... 20
        }
    }
}

public class SubThreadRunTest {
 
    public static void main(String[] args) {
 
        // 1.声明Thread类型的引用指向子类类型的对象
        Thread t1 = new SubThreadRun();
        // 2.调用run方法测试，本质上就是相当于对普通成员方法的调用，因此执行流程就是run方法的代码执行完毕后才能继续向下执行
        //t1.run();
        // 用于启动线程，Java虚拟机会自动调用该线程类中的run方法
        // 相当于又启动了一个线程，加上执行main方法的线程是两个线程
        t1.start();
 
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 20
        }
    }
}

（2）实现Runnable接口

　　定义一个类，实现Runnable接口并重写run方法，创建这个类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法。
       举个例：

public class SubRunnableRun implements Runnable {
    @Override
    public void run() {
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            System.out.println("run方法中：i = " + i); // 1 2 ... 20
        }
    }
}

public class SubRunnableRunTest {
 
    public static void main(String[] args) {
 
        // 1.创建自定义类型的对象，也就是实现Runnable接口类的对象
        SubRunnableRun srr = new SubRunnableRun();
        // 2.使用该对象作为实参构造Thread类型的对象
        // 由源码可知：经过构造方法的调用之后，Thread类中的成员变量target的数值为srr。
        Thread t1 = new Thread(srr);
        // 3.使用Thread类型的对象调用start方法
        // 若使用Runnable引用构造了线程对象，调用该方法(run)时最终调用接口中的版本
        // 由run方法的源码可知：if (target != null) {
        //                         target.run();
        //                    }
        // 此时target的数值不为空这个条件成立，执行target.run()的代码，也就是srr.run()的代码
        t1.start();
        //srr.start();  Error
 
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 20
        }
    }
}

（3）匿名内部类的方式

　　匿名内部类方式创建和启动线程，其实是上述两种方式的另外种写法。代码如下：

public class ThreadNoNameTest {
 
    public static void main(String[] args) {
 
        // 匿名内部类的语法格式：父类/接口类型 引用变量名 = new 父类/接口类型() { 方法的重写 };
        // 1.使用继承加匿名内部类的方式创建并启动线程
        /*Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("张三说：在吗？");
            }
        };
        t1.start();*/
        new Thread() {
            @Override
            public void run() {
                System.out.println("张三说：在吗？");
            }
        }.start();
 
        // 2.使用实现接口加匿名内部类的方式创建并启动线程
        /*Runnable ra = new Runnable() {
            @Override
            public void run() {
                System.out.println("李四说：不在。");
            }
        };
        Thread t2 = new Thread(ra);
        t2.start();*/
        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("李四说：不在。");
            }
        }).start();*/
        // Java8开始支持lambda表达式： (形参列表)->{方法体；}
        /*Runnable ra = ()-> System.out.println("李四说：不在。");
        new Thread(ra).start();*/
 
        new Thread(()-> System.out.println("李四说：不在。")).start();
    }
}

3、执行流程

（1）执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程。

（2）main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码， 线程继续向下执行，两个线程各自独立运行互不影响。

（3）当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束。

（4）两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定。

三、线程的生命周期

新建状态 - 使用new关键字创建之后进入的状态，此时线程并没有开始执行。   举例：生了两小孩，就是新建状态。

就绪状态 - 调用start方法后进入的状态，此时线程还是没有开始执行。    举例：两小孩坐在餐桌上，等待大人喂食，就是就绪状态。

运行状态 - 使用线程调度器调用该线程后进入的状态，此时线程开始执行，当线程的时间片执行完毕后任务没有完成时回到就绪状态。    举例：大人喂给哪个孩子食物，哪个孩子就处于运行状态。喂一口一个小孩后，再喂另外个小孩，刚喂过的这个孩子回到就绪状态。

消亡状态 - 当线程的任务执行完成后进入的状态，此时线程已经终止。    举例：其中一个孩子吃饱后，不需要吃了，就是消亡状态。

阻塞状态 - 当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法。阻塞状态解除后进入就绪状态。       举例：其中一个孩子吃的过程中，吃着吃着就睡着了，不继续吃了，这个时候就是阻塞状态。

四、常用的方法

1、sleep方法的使用

public class ThreadSleepTest extends Thread {
    // 声明一个布尔类型的变量作为循环是否执行的条件
    private boolean flag = true;
 
    // 子类中重写的方法不能抛出更大的异常
    @Override
    public void run() {
        // 每隔一秒获取一次系统时间并打印，模拟时钟的效果
        while (flag) {
            // 获取当前系统时间并调整格式打印
//            LocalDateTime.now();
            Date d1 = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(d1));
 
            // 睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String[] args) {
 
        ThreadSleepTest tst = new ThreadSleepTest();
        tst.start();
 
        // 主线程等待5秒后结束子线程
        System.out.println("主线程开始等待...");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 停止子线程  过时  不建议使用
        //tst.stop();
        tst.flag = false;
        System.out.println("主线程等待结束！");
    }
}

2、线程优先级的管理（getPriority方法的使用）

public class ThreadPriorityTest extends Thread {
    @Override
    public void run() {
        //System.out.println("子线程的优先级是：" + getPriority()); // 5  10  优先级越高的线程不一定先执行。
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程中：i = " + i);
        }
    }
 
    public static void main(String[] args) {
 
        ThreadPriorityTest tpt = new ThreadPriorityTest();
        // 设置子线程的优先级
        tpt.setPriority(Thread.MAX_PRIORITY);
        tpt.start();
 
        Thread t1 = Thread.currentThread();
        //System.out.println("主线程的优先级是：" + t1.getPriority()); // 5 普通的优先级
        for (int i = 0; i < 20; i++) {
            System.out.println("--主线程中：i = " + i);
        }
    }
}

3、线程的等待（join方法的使用）

public class ThreadJoinTest extends Thread {
    @Override
    public void run() {
        // 模拟倒数10个数的效果
        System.out.println("倒计时开始...");
        for (int i = 10; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("新年快乐！");
    }
 
    public static void main(String[] args) {
 
        ThreadJoinTest tjt = new ThreadJoinTest();
        tjt.start();
 
        // 主线程开始等待
        System.out.println("主线程开始等待...");
        try {
            // 表示当前正在执行的线程对象等待调用线程对象，也就是主线程等待子线程终止
            //tjt.join();
            tjt.join(5000); // 最多等待5秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //System.out.println("终于等到你，还好没放弃！");
        System.out.println("可惜不是你，陪我到最后！");
    }
}

五、线程同步机制

 1、基本概念

 　  书面语：

　　多个线程并发读写同一个临界资源时会发生线程并发安全问题。

       当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要对线程之间进行通信和协调，该机制就叫做线程的同步机制。

　　异步操作: 多线程并发的操作，各自独立运行。

　　同步操作: 多线程串行的操作，先后执行的顺序。