Java 多线程学习一（三种实现方式）

一、为什么要使用多线程编程？

先从总体上来说：

• 从计算机底层来说： 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
• 从当代互联网发展趋势来说： 现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。

再深入到计算机底层来探讨：

• 单核时代： 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。
• 多核时代: 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。

二、线程的状态转换

• NEW：初始状态，构建线程，没有调用start()方法
• Runnable：运行状态，Java线程将操作系统中的就绪和运行两种统称为“运行中”
• Running：运行状态，线程获得CPU时间片后，就处于运行状态
• Waiting：等待状态，表示线程进入等待状态，表示当前线程需要等待其他线程做出一些特定动作（通知或中断）
• Time_waiting：超时等待状态，不同于waiting，可以在指定时间自行返回
• Terminated：终止状态，当前线程执行完毕

问：这里有个需要注意的地方，为什么调用start()方法会执行run()方法，为什么不直接调用run()方法，调用start()之后，什么时候执行run()方法？

答：新建Thread对象后，进入new状态；调用start()方法，进入就绪状态，等待CPU时间片；CPU自动执行run()方法；如果直接执行run()方法，只是简单的普通方法调用而已。

三、多线程实现的三种简单方式

1、继承Thread类创建线程

Thread类本质上实现了Runnable接口，重写run()方法，通过Thread类实例的start()方法，并执行run()方法，示例代码

package ThreadDemo;
//继承Thread类
class MyThread extends Thread {
    @Override//重写run方法
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " is running");
    }
}

public class ThreadExtendsDemo {
    public static void main(String[] args) {
        //线程具有随机性
        for(int i=0;i<10;i++) {
            new MyThread().start();
        }
        System.out.println("最后一行代码");
    }
}

2、实现Runnable接口创建线程（Java1.1）

具体步骤如下：创建runnable对象——使用参数带runnable对象的构造方法创建Thread实例——调用start()方法启动线程

Java不支持多继承，继承Thread类的方式只能单继承

package ThreadDemo;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running");
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        //Thread类有两个构造方法
        Thread t0=new Thread(mr);
        Thread t = new Thread(mr, "Thread");
        //线程随机性
        t.start();
        t0.start();
        System.out.println("最后一行代码");
    }
}

3、实现Callable接口，通过FutureTask包装器来创建Thread线程（Java1.5）

• 创建Callable接口实现类，重写Call方法
• 创建类实例，使用FutureTask包装Callable对象实例，得到的FutureTask对象实例封装了call方法的返回值
• 将FutureTask对象实例作为Thread对象的target创建并启动线程
• 调用FutureTask对象实例的get()方法获取子线程执行结束返回值

注：get()方法会阻塞主线程，知道获取返回结果

对比Runnable接口，Callable接口call()方法可以有返回值，并且可以抛出异常，get()方法阻塞主线程。

package ThreadDemo;

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

class MyCallable implements Callable<String> {
    @Override//重写call方法，返回线程名称
    public String call() throws Exception {
        return Thread.currentThread().getName();
    }
}

public class CallableDemo {
    public static void main(String[] args) {
        //创建MyCallable对象
        MyCallable mc=new MyCallable();
        //创建FutureTask对象包装MyCallable对象
        FutureTask<String> ft=new FutureTask<>(mc);
        //创建Thread对象包装FutureTask对象，启动线程
        new Thread(ft).start();
        try {
            //调用get()方法，阻塞主线程
            System.out.println(ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //get()方法阻塞主线程，所以最后一行代码一定是”最后一行代码“
        System.out.println("最后一行代码");
    }
}

未完待续......