第十六讲 多线程(一)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yerenyuan_pku/article/details/82599065

线程与进程的概述

什么是进程？

进程就是应用程序在内存中分配的空间，也可理解为一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序就是一个执行路径或者叫一个控制单元。

什么是线程？

线程就是进程中负责程序执行的执行单元，也可理解为进程中的一个独立的控制单元。线程在控制着进程的执行。

多线程

什么是多线程？

一个进程中至少有一个线程在负责该进程的运行。如果一个进程中出现了多个线程，就称该程序为多线程程序。所谓的多线程是指一个进程在执行过程中可以产生多个单线程，这些单线程程序在运行时是相互独立的，它们可以并发执行，多线程程序的执行过程如下图所示。

图中所示的多条线程，看似是同时执行的，其实不然，它们和进程一样，也是由CPU轮流执行的，只不过CPU运行速度很快，故而给人同时执行的感觉。

多线程技术解决的问题

多线程这门技术的出现解决了多部分代码同时执行的需求，这样做的好处就是可以提高用户的体验效果。 这里有一个疑问，多线程真的能提高效率吗？显然不是，反倒容易死机，但可合理的使用CPU资源。

JVM中的多线程——主线程和垃圾回收线程

多线程的运行是根据CPU的切换完成的，怎么切换CPU说了算，所以多线程运行有一个随机性(CPU的快速切换造成的)。在这一小节中，我以Java程序运行的原理来简单讲解一下JVM中的多线程。
java命令会启动java虚拟机，即启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的main方法，所以main方法运行在主线程中，在此之前的所有程序都是单线程的。现在思考这样一个问题——JVM虚拟机的启动是单线程的还是多线程的？答案是JVM启动时启动了多条线程，至少有两个线程我们是可以分析的出来：

1. 执行main函数的线程，该线程的任务代码都定义在main函数中；
2. 负责垃圾回收的线程，System类的gc()方法告诉垃圾回收器调用对象的finalize方法，但不一定立即执行。

下面我通过一个简单的案例来演示JVM中的多线程。例如，有如下实验代码：

class Demo
{
    // 定义垃圾回收方法
    public void finalize()
    {
        System.out.println("demo ok");
    }

}
class FinalizeDemo 
{
    public static void main(String[] args) 
    {
        new Demo();
        new Demo();
        new Demo();
        new Demo();
        new Demo();
        System.gc(); // 启动垃圾回收器。
        System.out.println("Hello World!");
    }
}

运行FinalizeDemo类，可能在屏幕上打印(截图如下)：

通过实验会发现每次的结果不一定相同，那是因为随机性造成的。而且每一个线程都有自己的代码内容，这个称之为线程的任务，之所以创建一个线程就是为了去运行指定的任务代码，而线程的任务都封装在特定的区域中，比如：

1. 主线程运行的任务都定义在main方法中；
2. 垃圾回收线程在收垃圾时都会运行finalize方法。

多线程的实现方案一

如何在自定义的代码中，自定义一个线程呢？也即如何建立一个执行路径呢？通过对API的查找，Java已经提供了对线程这类事物的描述，即Thread类，该类的描述中创建线程有两种方式，下面我就来讲解其第一种方式，即继承Thread类，重写run()方法。

1. 继承Thread类；
2. 重写Thread类中的run()方法。目的：将自定义的代码存储在run()方法，让线程运行；
3. 创建子类对象也即创建线程对象；
4. 调用线程的start()方法。该方法有2个作用：启动线程和调用run()方法。

class Demo extends Thread {
    public void run() {
        for (int x = 0; x < 60; x++) {
            System.out.println("demo run---"+x);
        }
    }
}

class ThreadDemo {
    public static void main(String[] args) {
        Demo d = new Demo(); // 创建好一个线程
        // d.start(); // 开启线程，并执行该线程的run()
        d.run(); // 仅仅是对象的调用方法，而线程创建了，并没有被运行

        for (int x = 0; x < 60; x++) {
            System.out.println("Hello World!---"+x);
        }
    }
}

运行以上程序，可发现运行结果每一次都有不同，这是因为多个线程都在获取CPU的执行权，CPU执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行（多核除外）。CPU在做着快速的切换，以达到看上去是同时运行的效果，我们可以形象地把多线程的运行形容为互相抢夺CPU的执行权，这就是多线程的一个特点：随机性。谁抢到谁执行，至于执行多长，CPU说了算。

为什么要覆盖run()方法呢？

Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run()方法，也就是说Thread类中的run()方法用于存储线程要运行的代码。

调用start()方法和调用run()方法的区别？

调用start方法会开启线程，让开启的线程去执行run方法中的线程任务；而直接调用run方法，线程并未开启，去执行run方法的只有主线程。

扫描二维码关注公众号，回复： 3150589 查看本文章

Thread类的基本获取和设置方法

方法摘要	方法描述
static Thread currentThread()	获取当前线程对象
public final String getName()	获取线程的名称
public final void setName(String name)	设置线程的名称
Thread(String name)	通过构造方法给线程起名字

例，创建两个线程，和主线程交替执行。

class Demo extends Thread
{
    private String name;
    Demo (String name)
    {
        this.name = name;
    }

    //覆盖run()方法
    public void run()
    {
        for (int x = 1; x <= 40; x++)
        {
            System.out.println(Thread.currentThread().getName() + "....." + name + "....." + x);
        }
    }
}

class ThreadDemo 
{
    public static void main(String[] args) 
    {
        Demo d1 = new Demo("张三");//Thread-0
        Demo d2 = new Demo("麻子");
        d1.start();//start()做了两件事：1.开启线程，2.调用run()方法
        d2.start();

        for (int x = 1; x < 40; x++)
        {
            System.out.println(Thread.currentThread().getName() + "--------" + x);
        }
    }
}

通过上例，可发现原来线程都有自己默认的名称：Thread-编号，该编号从0开始。

多线程的运行状态

多线程的运行状态用图来表示即为：

多线程的实现方案二

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

1. 定义类实现Runnable接口；
2. 覆盖Runnable接口中的run()方法。目的：将线程要运行的代码存放在该run()方法中；
3. 通过Thread类建立线程对象；
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数呢？因为自定义的run()方法所属的对象是Runnable接口的子类对象，所以要让线程去运行指定对象的run()方法，就必须明确该run()方法所属的对象；
5. 调用Thread类的start()方法开启线程并调用Runnable接口子类的run()方法。

例，简单的卖票程序，多个窗口同时卖票。

class SaleTicket implements Runnable
{
    private int tickets = 100;

    public void run()
    {
        while (true)
        {
            if (tickets > 0)
            {
                System.out.println(Thread.currentThread().getName() + "...." + tickets--);
            }
        }
    }
}

class TicketDemo2 
{
    public static void main(String[] args) 
    {
        //线程任务对象。
        SaleTicket t = new SaleTicket();

        //创建四个线程。通过Thread类的对象。
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

实现Runnable接口的好处

将实现Runnable接口的好处总结如下：

1. 避免了继承Thread类的单继承的局限性；
2. Runnable接口的出现更符合面向对象，将线程任务单独进行了对象的封装；
3. Runnable接口的出现降低了线程任务和线程对象的耦合性。

所以，以后创建线程都使用第二种方式。