《疯狂java讲义》学习（42）：多线程

版权声明：本文为博主原创文章，如若转载请注明出处 https://blog.csdn.net/tonydz0523/article/details/87118549

多线程

大部分时候我们都是做着单线程编程，只有一条顺序执行，如果遇到阻塞就会停滞，但是单线程的程序往往功能非常有限，例如，我们开发一个简单的服务器程序，这个服务器程序需要向不同的客户端提供服务时，不同的客户端之间应该互不干扰，否则会让客户端感觉非常沮丧。多线程听上去是非常专业的概念，其实非常简单——单线程的程序（前面介绍的绝大部分程序）只有一个顺序执行流，多线程的程序则可以包括多个顺序执行流，多个顺序流之间互不干扰。我们可以这样理解：单线程的程序如同只雇佣一个服务员的餐厅，他必须做完一件事情后才可以做下一件事情；多线程的程序则如同雇佣多个服务员的餐厅，他们可以同时做多件事情。

线程概述

几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

线程和进程

几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序进入内存运行时，即编程一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。
一般而言，进程有如下特征：

• 独立性：进程是系统中独立存在的实体，它有自己的独立资源，每个进程都拥有自己的是有的地址空间。如果没有进程允许，一个用户进程无法访问其他进程地址空间。
• 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的声明周期和各种不同的状态，这些概念在程序中都是不具备的。
• 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会相互影响。

并发性（concurrency）和并行性（parallel）是两个概念，并行指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

对于一个CPU而言，它在某个时间点只能执行一个程序，也就是说，只能运行一个进程，CPU不断地在这些进程之间轮换执行。那么为什么我们感觉不到任何中断现象呢？这是因为CPU的执行速度相对我们的感觉来说实在是太快了（当然，如果启动的程序足够多，我们依然可以感觉到程序的运行速度下降），所以虽然CPU在多个进程之间轮换执行，但我们感觉到好像有多个进程在同时执行。

多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程（Thread）也被称作轻量级进程（Lightweight Process），线程是进程的执行单元。就像进程在操作系统中的地位一样，线程在程序中是独立的、并发的执行流。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅要求有一个主线程，但也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每个线程也是互相独立的。

一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源，因此编程更加方便；但必须更加小心，我们必须确保线程不会妨碍到统一进程中的其他线程。
线程是独立运行的，它不知道进程中是否有其他线程存在。线程的执行是抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另外一个线程可以运行。
一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。
从逻辑角度来看，多线程存在于一个应用程序中，让一个应用程序中可以有多个执行部分同时执行，但操作系统无需将多个线程看做多个独立的应用，对多线程实现调度和管理以及资源分配。线程的调度和管理有进程本身负责完成。
简而言之，一个程序运行后至少有一个进程，一个进程里可以有很多线程但是至少有一个线程。

操作系统可以同时执行多个任务，每个任务就是进程；进程可以同时执行多个任务，每个任务就是线程。

多线程的优势

因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性——多个线程共享同一个进程虚拟空间。线程共享的环境包括：进程代码段、进程的公有数据等。利用这些共享的数据，线程很容易实现相互之间的通信。
当操作系统创建一个进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源；但创建一个线程则简单得多，因此使用多线程来实现并发比使用多进程实现并发的性能要高得多。
总结起来，使用多线程编程具有如下几个优点。

• 进程之间不能共享内存，但线程之间共享内存非常容易。
• 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。
• Java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

在实际应用中，多线程是非常有用的，一个浏览器能同时下载多个图片；一个Web服务器必须同时相应多个用户请求;Java虚拟机本身就在后台提供了一个超级线程来进行来及回收；图形用户界面应用也需要启动单独的线程从主机环境收集用户界面事件……总之，多线程在实际编程中应用是非常广泛的。

线程的创建和启动

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流（一段顺序执行的代码）。Java使用线程执行体来代表这段程序流。

继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象。。
3. 调用线程对象的start()方法来启动该线程。

如下程序示范了Thread使用：

package FirstThread;

public class FirstThread extends Thread{
    private int i;
    // 重写run方法，run方法的方法体就是线程执行体
    public void run() {
        for (; i<100; i++) {
            //当线程类继承Thread类时，直接使用this即可
            // Thread对象的getName()返回当前线程的名字
            // 因此可以直接调用getName()方法返回当前线程的名字
            System.out.println(getName() + "" + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            // 调用Thread的currentThread方法获取当前线程
            System.out.println(Thread.currentThread().getName() + "" + i);
            if (i == 20) {
                // 创建并启动第一个线程
                new FirstThread().start();
                // 创建并启动第二个线程
                new FirstThread().start();
            }
        }
    }
}

上面程序中的FirstThread类继承了Thread类，并实现了run()方法，如程序中第一段粗体字代码所示，该run()方法里的代码执行流就是该线程所需要完成的任务。程序的主方法中包含了一个循环，当循环变量i等于20时创建并启动两个新线程。虽然程序只启动了两个线程，但实际上程序有三个线程，即程序显示创建的2个子线程和主线程。前面已经提到，当Java程序开始运行后，程序至少会创建一个主线程，主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的——main()方法的方法体代表主线程的线程执行体。
除此之外，上面程序还用到了线程的如下两个方法。

• Thread.currentThread()：currentThread()是Thread类的静态方法，该方法总是返回当前正在执行的线程对象。
• getName()：该方法是Thread类的实例方法，该方法返回调用该方法的线程名字。

Thread-0和Thread-1两个线程输出的i变量不连续——注意：i变量是FirstThread的实例属性，而不是局部变量，但因为程序每次创建线程对象时都需要创建一个FirstThread对象，所以Thread-0和Thread-1不能共享该实例属性。

使用继承Thread类的方法来创建线程类时，多个线程之间无法共享线程类的实例变量。

实现Runnable接口创建线程类

实现Runnable接口来创建并启动多线程的步骤：

1. 定义Runnable接口的实现类，并重写run方法，该run方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象：

// 创建Runnable实现类的对象
SecondThread st=new SecondThread();
// 以Runnable实现类的对象作为Thread的target来创建Thread对象，即线程对象
new Thread(st);

也可以在创建Thread对象时为该Thread对象指定一个名字，代码如下所示：

// 创建Thread对象时指定target和新线程的名字
new Thread(st , "新线程1");

3. 调用线程对象的start()方法来启动该线程。

下面程序示范了通过实现Runnable接口来创建并启动多线程：

package SecondThread;

// 通过实现Runnable接口来创建线程类
public class SecondThread implements Runnable {

    private int i;

    //run()方法同样是线程执行体
    public void run() {
        for (; i < 100; i++) {
            //当线程类实现Runnable接口时
            //如果想获取当前线程，只能用Thread.currentThread()方法
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()
                    + "  " + i);
            if (i == 20) {
                SecondThread st = new SecondThread();    // ①
                // 通过new Thread(target , name)方法创建新线程
                new Thread(st, "新线程1").start();
                new Thread(st, "新线程2").start();
            }
        }
    }
}

对比FirstThread中的run()方法体和SecondThread中的run()方法体不难发现，通过继承Thread类来获得当前线程对象比较简单，直接使用this就可以了；但通过实现Runnable接口来获得当前线程对象，则必须使用Thread.currentThread()方法。
在FirstThread和SecondThread中创建线程对象的方式有所区别：前者直接创建的Thread子类即可代表线程对象；后者创建的Runnable对象只能作为线程对象的target。
两个子线程的i变量是连续的，也就是采用Runnable接口的方式创建的多个线程可以共享线程类的实例属性。这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多个线程可以共享同一个target，所以多个线程可以共享同一个线程类（实际上应该是线程的target类）的实例属性。

使用Callable和Futura创建线程

从Java 5开始，Java提供了Callable接口，该接口怎么看都像是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大。

• call()方法可以有返回值。
• call()方法可以声明抛出异常。

因此我们完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是该Callable对象的call方法。问题是：Callable接口是Java5新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。而且call()方法还有一个返回值——call()方法并不是直接调用，它是作为线程执行体被调用的。那么如何获取call()方法的返回值呢？
Java 5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口——可以作为Thread类的target。
在Future接口里定义了如下几个公共方法来控制它关联的Callable任务：

• boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future里关联的Callable任务。
• V get()：返回Callable任务里call()方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。
• V get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException异常。
• boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。
• boolean isDone()：如果Callable任务已完成，则返回true。

Callable接口有泛型限制，Callable接口里的泛型形参与call（）方法返回值类型相同。

创建并启动有返回值的线程的步骤如下：

1. 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值。
2. 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
3. 使用FutureTask对象作为Thread对象的target创建并启动新线程。
4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

// 实现Callable接口来实现线程类

public class ThirdThread implements Callable<Integer> {
    // 实现call()方法，作为线程执行体
    public Integer call() {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：" + i);
        }
        // call()方法可以有返回值
        return i;
    }

    public static void main(String[] args) {

        // 创建Callable对象
        ThirdThread rt = new ThirdThread();
        // 使用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<>(rt);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()
                    + " 的循环变量i的值：" + i);
            if (i == 20) {
                // 实质还是以Callable对象来创建并启动线程
                new Thread(task, "有返回值的线程").start();
            }
        }
        try {
            // 获取线程返回值
            System.out.println("子线程的返回值：" + task.get());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

上面程序中创建Callable实现类与创建Runnable实现类并没有太大的差别，只是Callable的call()方法允许声明抛出异常，而且允许带返回值。
上面程序中的粗体字代码是以Callable对象来启动线程的关键代码。程序先创建一个Callable实现类的实例，然后将该实例包装成一个FutureTask对象。主线程中当循环变量i等于20时，程序启动以FutureTask对象为target的线程。程序最后调用FutureTask对象的get()方法来返回call()方法的返回值——该方法将导致主线程被阻塞，直到call()方法结束并返回为止。
运行上面程序，将看到主线程和call()方法所代表的线程交替执行的情形，程序最后还会输出call()方法的返回值。

创建线程的三种方式对比

通过继承Thread类或实现Runnable、Callable接口都可以实现多线程，不过实现Runnable接口与实现Callable接口的方式基本相同，只是Callable接口里定义的方法有返回值，可以声明抛出异常而已。因此可以将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式之间的主要差别如下。
采用实现Runnable、Callable接口的方式创建多线程——

• 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
• 在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
• 劣势是：编程稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。
  +承Thread类的方式创建多线程——
• 劣势是：因为线程类已经继承了Thread类，所以不能再继承其他父类。
• 优势是：编写简单，如果需要访问当前线程，则无须使用Thread.currentThread()方法，直接使用this即可获得当前线程。

鉴于上面分析，因此一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

Java实例练习

查看线程的运行状态

线程共有5种状态：新建、运行、阻塞、等待和终止。当使用new关键字创建新线程时，线程处于“新建”状态；当调用start()方法时，线程处于运行状态；当线程需要获得对象的内置锁，而该锁正被其他线程拥有时，线程处于阻塞状态；当线程等待其他线程通知调度表可以运行时，该线程处于等待状态；当run()方法运行完毕或出现异常时，线程处于终止状态。

1.

新建项目Multithreading，并在其中创建一个ThreadState.java文件。该类实现了Runnale接口。在其中定义了三个方法：waitForASecond()方法用于将当前线程暂停0.5秒，waitForYears()方法用于将当前线程永久等待，notifyNow()方法用于通知等待运行的线程继续运行。在run()方法中，运行了waitForASecond()方法和waitForYears()方法:

package Multithreading;

public class ThreadState implements Runnable{
    public synchronized void waitForASecond() throws InterruptedException {
        wait(500);  // 使当前线程等待0.5秒或其他线程调用notify()或notifyAll()方法
    }
    public synchronized void waitForYears() throws InterruptedException {
        wait();   // 使当前线程永久等待，直到其他线程调用notify()或notifyAll()方法
    }
    public synchronized void notifyNow() throws InterruptedException {
        notify();                    // 唤醒由调用wait()方法进入等待状态的线程
    }

    public void run() {
        try {
            waitForASecond();     //在新线程中运行waitForASecond
            waitForYears();          // 在新线程中运行waitForYears()方法

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.

编写一个Multithread类进行测试，在main()方法中，输出了线程的各种不同的状态:

package Multithreading;

public class Multithread {
    public static void main(String[] args) throws InterruptedException {
        ThreadState state = new ThreadState();   // 创建State对象
        Thread thread = new Thread(state);       // 利用State对象创建Thread对象
        System.out.println("新建线程：" + thread.getState());   // 输出线程状态
        thread.start();             // 调用thread对象的start()方法，启动新线程
        System.out.println("启动线程：" + thread.getState());   // 输出线程状态
        Thread.sleep(100);      //当前线程休眠0.1秒，使新线程运行waitForASecond()方法
        System.out.println("计时等待：" + thread.getState());   // 输出线程状态
        Thread.sleep(1000);         //当前线程休眠1秒，使新线程运行waitForYears()方法
        System.out.println("等待线程：" + thread.getState());   // 输出线程状态
        state.notifyNow(); // 调用state的notifyNow()方法
        System.out.println("唤醒线程：" + thread.getState());// 输出线程状态
        Thread.sleep(1000);                           //当前线程休眠1秒，使新线程结束
        System.out.println("终止线程：" + thread.getState());   // 输出线程状态
    }
}

线程从其创建到死亡具有一个完整的生命周期，在整个生命周期中处于各种状态。线程的状态表明线程当前可以进行的活动。一个生命周期内的线程主要包括创建、就绪、运行、阻塞、死亡状态：

1. 创建状态：在线程类使用new关键字实例化之后且在调用start()方法之前，线程处于创建状态。处于创建状态的线程仅仅分配了内存空间，属于生命周期的初始状态。
2. 就绪状态：在线程调用了start()方法后即处于就绪状态。处于就绪状态的线程具备了除CPU之外所有运行所需资源。就绪状态线程排队等待CPU，由系统调度为其分配。
3. 运行状态：处于就绪状态的线程获得CPU之后即处于运行状态。处于运行状态的线程才开始真正执行线程run()方法的内容。
4. 阻塞/等待状态：处于运行状态的线程如果因为某种原因不能继续执行，则进入阻塞状态。阻塞状态与就绪状态的不同是：就绪状态只是因为缺少CPU而不能执行，而阻塞状态是由于各种原因引起线程不能执行，不仅仅是缺少CPU。引起阻塞的原因解除以后，线程再次转为就绪状态，等待分配CPU运行。
5. 死亡状态：当线程执行完run()方法的内容或被强制终止时，线程处于死亡状态，线程的整个生命周期结束。