软件设计基础实践-Java高级特性-多线程基础(1)

本文介绍了Java中的线程和进程概念,重点讲解了如何通过继承Thread类和实现Runnable接口创建线程,以及使用Callable和Future实现有返回值的线程。通过实例展示了线程交替执行和获取执行结果的方法。
摘要由CSDN通过智能技术生成

第1关:创建线程

  • 任务要求
  • 参考答案
  • 评论86

任务描述

本关任务:创建一个Java线程执行特定任务。

相关知识

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

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

本小节我们来学习Java中程序是如何同时执行多个任务的。

为了完成本关任务,你需要掌握:

1.什么是线程、什么是进程;

2.如何创建线程。

什么是线程、什么是进程

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

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

怎么理解呢?

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

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

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

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

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

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

如何创建线程

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

1.继承Thread类;

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

示例:

 
  1. class MyThread extends Thread{
  2. private String name;
  3. public MyThread(String name) {
  4. super();
  5. this.name = name;
  6. }
  7. public void run() {
  8. System.out.println("线程" + name +"开始运行");
  9. for (int i = 0; i < 5; i++) {
  10. System.out.println("线程" + name + "运行" + i);
  11. }
  12. System.out.println("线程" + name + "结束");
  13. }
  14. }
  15. public class Test {
  16. public static void main(String[] args) {
  17. Thread t = new MyThread("T!");
  18. t.start();
  19. Thread t2 = new MyThread("T2");
  20. t2.start();
  21. }
  22. }

运行结果: 线程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接口。

示例:

 
  1. class MyThread implements Runnable {
  2. private String name;
  3. private Thread mythread;
  4. public MyThread(String name) {
  5. super();
  6. this.name = name;
  7. }
  8. public void run() {
  9. for (int i = 0; i < 5; i++) {
  10. System.out.println("线程" + name + "运行" + i);
  11. }
  12. System.out.println("线程" + name + "结束");
  13. }
  14. public void start() {
  15. System.out.println("线程开始: " + name);
  16. if (mythread == null) {
  17. mythread = new Thread(this, name);
  18. mythread.start();
  19. }
  20. }
  21. }
  22. public class Test {
  23. public static void main(String[] args) {
  24. MyThread t1 = new MyThread("T1");
  25. t1.start();
  26. MyThread t2 = new MyThread("T2");
  27. t2.start();
  28. }
  29. }

运行结果:

线程开始: 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

测试说明

因为需要完成两个文件的编写,所以你需要在右侧进行文件切换。

平台会判断你定义的类是否是一个线程类,并且调用run方法,判断是否达到预期的输出结果。


开始你的任务吧,祝你成功!

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

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

  • 任务要求
  • 参考答案
  • 评论86

任务描述

本关任务:通过 CallableFuture 来创建线程。

相关知识

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

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

而如果使用CallableFuture,通过它们就可以在任务执行完毕之后得到任务执行结果

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

1.什么是CallableFuture

2.如何通过CallableFuture创建线程。

Callable和Future

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

使用步骤如下:

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

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

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

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

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

 
  1. public class Test {
  2. public static void main(String[] args) {
  3. CallableThreadTest cts = new CallableThreadTest();
  4. // 接收
  5. FutureTask<Integer> ft = new FutureTask<>(cts);
  6. new Thread(ft, "有返回值的线程").start();
  7. for (int i = 0; i < 30; i++) {
  8. System.out.println( "main" + " 的循环变量i的值:" + i);
  9. }
  10. try {
  11. System.out.println("子线程的返回值:" + ft.get());
  12. } catch (Exception e) {
  13. e.printStackTrace();
  14. }
  15. }
  16. }
  17. class CallableThreadTest implements Callable<Integer> {
  18. public Integer call() throws Exception {
  19. int i = 0;
  20. for (; i < 30; i++) {
  21. System.out.println(Thread.currentThread().getName() + " " + i);
  22. }
  23. return i;
  24. }
  25. }

运行这段程序你应该可以获取到类似如下结果(每次运行的结果不一致): ... ... 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........

测试说明

补充完代码后,点击测评,平台会对你编写的代码进行测试,当你的结果与预期输出一致时,即为通过。

输入:3 输出:线程的返回值为:2

输入:5 输出:线程的返回值为:5


开始你的任务吧,祝你成功!

package step2; //声明该类所在的包
 
import java.util.concurrent.Callable; //引入需要使用的类
import java.util.concurrent.FutureTask;
 
public class Task { //定义task类
 
	public void runThread(int num) { //定义runThread方法
    //请在此添加实现代码
/********** Begin **********/
// 在这里开启线程 获取线程执行的结果
/*这三句代码的作用是创建一个可在另一个线程中执行的任务,并将其封装在一个FutureTask对象中,最后将该FutureTask对象传递给一个新的线程对象,以便在该线程中执行这个任务*/
ThreadCallable t1 = new ThreadCallable(num); 
FutureTask<Integer> ft1 = new FutureTask<>(t1); 
Thread thread1 = new Thread(ft1,"thread1"); 
 
thread1.start(); // 启动线程
try{ // 获取线程执行的结果
    System.out.println("线程的返回值为:"+ft1.get());
}catch(Exception e){
    e.printStackTrace();
}
/********** End **********/
	}
}
 
//请在此添加实现代码
/********** Begin **********/
/* 在这里实现Callable接口及方法 */
class ThreadCallable implements Callable<Integer>    {
    int num;
    ThreadCallable(int num){
        this.num = num;
    }
    ThreadCallable(){
 
    }
     
    public Integer call() throws Exception{
        return getNum(num);
    }
 
    private int getNum(int num){
        if(num<3){
            return 1;
        }
        else{
            return getNum(num-1) +getNum(num-2);
        }
    }
}
 
/********** End **********/

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值