Educoder/头歌JAVA——JAVA高级特性：多线程基础（1）使用线程

第1关：创建线程

相关知识

不知道你有没有发现，截止目前，我们编写的代码都是在main()函数中依照编写代码的顺序从上到下依次运行的。

但是我们平常使用的软件基本都是可以多个任务同时执行的，这其中的运行机制是什么呢？这一小节我们就来探讨。

什么是线程、什么是进程

在Java中要同时执行（如果是单核，准确的说是交替执行）多个任务，使用的是多线程，而要理解线程，我们先要了解什么是进程什么是线程。

一般的定义：进程是指在操作系统中正在运行的一个应用程序，线程是指进程内独立执行某个任务的一个单元。

比如说QQ是是一个进程，如果你在和A朋友语音聊天的同时和B朋友打字聊天，同时还在QQ群下载图片，这三个操作就相当于开启了三个线程，可以说有了线程之后我们设计的程序就可以一边执行A操作，一边执行B操作了。

线程和进程有什么区别呢？首先最直观的就是：一个进程可拥有多个线程。 具体比较：

• **调度 ** 进程拥有资源； 线程是调度和分派的基本单位； 同一进程中线程的切换不会引起进程的切换； 进程间的线程切换则会引起进程切换从而导致资源切换等。

• **并发性 ** 进程：进程和进程之间可并发执行 ； 线程：除了进程间的并发执行还可以线程之间并发执行； 线程的并发性更高。

• **拥有资源 ** 线程并不能拥有资源，只有进程才拥有资源。

• **系统开销 ** 进程创建、切换和撤销都会导致系统为之创建或者回收进程控制卡以及资源，但是线程的创建以及线程间的切换并不会引起系统做这些事儿，所以线程的系统开销明显更小。

如何创建线程

在这里我们主要掌握两种创建线程的方式。

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

1.继承Thread类；

我们可以使用继承Thread类的方式来创建一个线程。 创建一个类来继承Thread类，重写父类的run方法，就实现了创建我们自己的线程了。之后调用线程的start方法，就算是开启了一个线程了。

示例：

class MyThread extends Thread{
    private String name;
    public MyThread(String name) {
        super();
        this.name = name;
    }
    public void run() {
        System.out.println("线程" + name +"开始运行");
        for (int i = 0; i < 5; i++) {
            System.out.println("线程" +  name + "运行" + i);
        }
        System.out.println("线程" + name + "结束");
    }
}
public class Test {
    public static void main(String[] args) {
        Thread t = new MyThread("T!");
        t.start();
        Thread t2 = new MyThread("T2");
        t2.start();
    }
}
/*_________________________________*/
运行结果：
线程T!开始运行
线程T2开始运行
线程T!运行0
线程T2运行0
线程T!运行1
线程T2运行1
线程T!运行2
线程T!运行3
线程T!运行4
线程T2运行2
线程T2运行3
线程T2运行4
线程T2结束
线程T!结束

运行这段代码我们会发现，线程是交替运行的，并且每次运行输出的结果都不一样，输出是随机的。

2.实现Runnable接口。

最简单创建线程的方法就是实现一个Runnable接口了，实际上所有的线程都是直接或者间接实现了Runnable接口的，上一个例子中Thread类其实就实现了Runnable接口。

示例：

class MyThread implements Runnable {
    private String name;
    private Thread mythread;
    public MyThread(String name) {
        super();
        this.name = name;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程" + name + "运行" + i);
        }
        System.out.println("线程" + name + "结束");
    }
    public void start() {
        System.out.println("线程开始： " + name);
        if (mythread == null) {
            mythread = new Thread(this, name);
            mythread.start();
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("T1");
        t1.start();
        MyThread t2 = new MyThread("T2");
        t2.start();
    }
}
/*____________________________________*/
运行结果：
线程开始： T1
线程开始： T2
线程T1运行0
线程T2运行0
线程T1运行1
线程T1运行2
线程T1运行3
线程T1运行4
线程T1结束
线程T2运行1
线程T2运行2
线程T2运行3
线程T2运行4
线程T2结束

在Java1.5版本之后，还提供了一种创建线程的方式： 通过Callable 和 Future 创建线程，这个我们将在之后的实训中学习到。

创建线程的两种方式对比

• 实现Runnable创建线程时，线程类只是实现了Runnable接口，还可以继承其他的类。

• 继承THread类创建线程时，线程类继承了Thread类，不能再继承其他类。不过这种方式编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用this即可获得当前线程。

java程序默认启动的线程

在Java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个jvm，每一个jvm实际在就是在操作系统中启动了一个进程。

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

• 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9；

• 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-10之间的偶数，输出结果如下： 0 2 4 6 8 10

/********** ThredClassOne.java **********/
package step1;

//请在此添加实现代码
/********** Begin **********/
public class ThreadClassOne extends Thread {
    private String name;
    
    public ThreadClassOne() {
        super();
    }
    public void run() {
        for (int i = 1; i < 10; i+=2) {
            System.out.print(i+" ");
        }
    }
}
/********** End **********/

/********** ThreadClassTwo.java **********/
package step1;

//请在此添加实现代码
/********** Begin **********/
public class ThreadClassTwo implements Runnable {
    private String name;
    private Thread mythread;
    public ThreadClassTwo () {
        super();
    }
    public void run() {
        for (int i = 0; i <=10; i+=2) {
            System.out.print(i+" ");
        }
    }
    public void start() {
        //System.out.println("线程开始： " + name);
        if (mythread == null) {
            mythread = new Thread(this, name);
            mythread.start();
        }
    }
}
/********** End **********/

第2关：使用 Callable 和 Future 创建线程

相关知识

从Java1.5版本开始，就提供了 Callable 和 Future 来创建线程，这种方式也是在Java程序员面试中经常会被问到的问题。

上一小节介绍了Thread和Runnable两种方式创建线程，不过这两种方式创建线程都有一个缺陷：在执行完任务之后无法获取执行结果。 如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。

而如果使用Callable和Future，通过它们就可以在任务执行完毕之后得到任务执行结果。

本小节你需要掌握的知识有：

1.什么是Callable和Future；

2.如何通过Callable和Future创建线程。

Callable和Future

它们俩其实挺有意思，在运行的时候各司其职，Callable产生结果，Future获取结果。

使用步骤如下：

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值；

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值；

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程；

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

接下来通过一个示例来学习这两个对象的使用：

public class Test {
    public static void main(String[] args) {
        CallableThreadTest cts = new CallableThreadTest();
        // 接收
        FutureTask<Integer> ft = new FutureTask<>(cts);
        new Thread(ft, "有返回值的线程").start();
        for (int i = 0; i < 30; i++) {
            System.out.println( "main" + " 的循环变量i的值：" + i);
        }
        try {
            System.out.println("子线程的返回值：" + ft.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class CallableThreadTest implements Callable<Integer> {
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 30; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
}
/*******************************/
运行这段程序你应该可以获取到类似如下结果（每次运行的结果不一致）：
...
...
main 的循环变量i的值：28
main 的循环变量i的值：29
有返回值的线程 23
有返回值的线程 24
有返回值的线程 25
有返回值的线程 26
有返回值的线程 27
有返回值的线程 28
有返回值的线程 29
子线程的返回值：30

由于输出过长，省略了部分结果，可以发现在最后接收到了子线程的返回值。

在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！

细心的你会发现这个结果是call函数的返回值，怎么拿到这个返回值的呢？是通过FutureTask拿到的，使用ft.get()方法即可获得线程的返回值，这就是一个简单的使用Callable和Future的过程了。

关于Callable和Future的使用，以及他们的常用函数，我们将会在后续的实训中学习。

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

• 在runThread(int num)函数中执行线程，创建Callable线程，Callable线程需要执行求第num项斐波那契数列的值，最后在runThread函数中获取Callable线程执行的结果，并打印输出。

斐波那契数列（Fibonacci数列） 这个数列从第3项开始，之后的每一项都等于它的前两项数字之和。 这个数列为： 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368........

package step2;

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

public class Task {

	public void runThread(int num) {
    //请在此添加实现代码
/********** Begin **********/
// 在这里开启线程 获取线程执行的结果
ThreadCallable callable = new ThreadCallable(num);
	FutureTask<Integer> futureTask = new FutureTask<>(callable);
	new Thread(futureTask).start();//开启线程
	try {
		Integer result = futureTask.get();
		System.out.println("线程的返回值为：" + result);
	} catch (Exception e) {
		e.printStackTrace();
	}

/********** End **********/	
    }
}
//请在此添加实现代码
/********** Begin **********/

/* 在这里实现Callable接口及方法 */

class ThreadCallable implements Callable<Integer>{
	private int num;
    public ThreadCallable() {
    }
    public ThreadCallable(int num) {
        this.num = num;
    }
    public Integer call() throws Exception {//得到斐波那契数列的值
        int[] arr = new int[2];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < num; i++) {
            int temp = arr[1];
            arr[1] = arr[0] + arr[1];
            arr[0] = temp;
        }
        return arr[1];
    }
}
/********** End **********/