32.认识多线程和线程的创建方式以及区别【20220810】

本文介绍了进程、线程和多线程的概念,解释了使用多线程的原因是为了提高程序执行效率和解决并发问题。文章详细阐述了Java中四种创建线程的方式:继承Thread类、实现Runnable接口、使用Callable和Future接口以及线程池,并对比了它们的区别,特别是对资源共享和返回值的处理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.什么是进程?

进程:在操作系统中运行的某个软件/某个程序
任何软件/程序要运行都要被加载到内存中,而内存负责运行这个软件/程序所需要的那些内存空间,就被称为当前软件在内存中的一个进程。
进程需要依赖于操作系统
进程就是在操作系统中动态运行的静态代码。

2.什么是线程?

线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】。
例如:我们在window操作系统上打开“暴风影音”播放电影,此时“暴风影音”就会在window操作系统中产生一个进程;打开“暴风影音”播放电影的时候有画面,声音,中文字幕等等,这些画面,声音,中文字幕就是这个“暴风影音”进程中的多个线程。

3.什么是多线程?

多线程:某一个程序在运行的时候可能会产生多个不同的执行线索【执行轨迹】,这些多个不同的执行线索【执行轨迹】共同运行的情况就是多线程。
往往我们会感觉到这些多个不同的执行线索【执行轨迹】同时执行,实际上这时一种错觉假象,实际上当这些多个不同的执行线索【执行轨迹】在运行的时候,某一个时刻只有一个执行线索【执行轨迹】在运行,只是这多个不同的执行线索【执行轨迹】快速的切换而已。

4.为什么使用多线程?

1.使用多线程的目的就是为了提高程序的执行效率。
2.解决并发问题。
并行和并发有什么区别?
并行:多个处理器或多核处理器同时处理多个任务。
并发:多个任务在同一个 CPU 核上,按细分的时间片轮流(交替)执行,从逻辑上来看那些任务是同时执行。

5.多线程的创建方式以及区别?

第一种,通过继承Thread类创建线程类
创建步骤:
1.创建一个类,继承Thread类
2.重写run方法
3.将需要由线程执行的具体动作写入run方法

package com.wangxing.test1;
public class MyThreadClass extends Thread{
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			//得到当前正在运行的线程名称
			//1.得到当前正在运行的线程对象
			Thread  dangqianObj=Thread.currentThread();
			//2.得到线程名称
			String name=dangqianObj.getName();
			System.out.println(name+"---i=="+i);
		}
	}
}

运行步骤:
1.创建线程类的对象
2.通过线程对象调用start方法启动线程

package com.wangxing.test1;
public class TestMain {
	public static void main(String[] args) {
		//启动运行线程
		//创建线程对象
		MyThreadClass  mtc1=new MyThreadClass();
		MyThreadClass  mtc2=new MyThreadClass();
		//启动线程
		mtc1.start();
		mtc2.start();
	}
}

第二种,通过实现Runnable接口创建线程类
Runnable接口--Thread类就实现过这个接口,只有一个run方法。
创建步骤:
1.创建一个类,实现Runnable接口
2.重写run方法
3.将需要由线程执行的具体动作写入run方法

package com.wangxing.test2;
public class MyTestThreadClass implements Runnable{
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			//得到当前正在运行的线程名称
			//1.得到当前正在运行的线程对象
			Thread  dangqianObj=Thread.currentThread();
			//2.得到线程名称
			String name=dangqianObj.getName();
			System.out.println(name+"---i=="+i);
		}
	}
}

运行步骤:
1.创建目标对象
2.通过Thread类的构造方法创建线程对象
3.通过线程对象调用start方法启动线程

package com.wangxing.test2;
public class TestMain {
	public static void main(String[] args) {
		//创建目标对象
		MyTestThreadClass  mttc=new MyTestThreadClass();
		//通过Thread类的构造方法
		//public Thread(Runnable target)
		//将目标对象转换成线程对象
		Thread  th1=new Thread(mttc);
		Thread  th2=new Thread(mttc);
		//启动线程调用start方法---Thread类
		th1.start();
		th2.start();
	}
}

第三种,通过Callable和Future接口创建线程
java.util.concurrent.Callable接口--这个接口中只有一个方法call()
java.util.concurrent.Future接口--有一个重要方法get()
    1. public boolean cancel(boolean mayInterruptIfRunning)
        是否取消正在执行的线程任务[false为取消任务]
    2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
    3. public boolean isDone()判断线程任务是否正常执行完毕
    4. V get()得到线程任务的执行结果
java.util.concurrent.FutureTask类--继承了Runnable接口
    1. public boolean cancel(boolean mayInterruptIfRunning)是否取消正在执行的线程任务
    2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
    3. public boolean isDone()判断线程任务是否正常执行完毕
    4. V get()得到线程任务的执行结果

创建步骤:
1.创建一个类,实现Callable接口
2.重写call();
3.将需要由线程执行的具体动作写入call()方法
注意:实现Callable接口的时候需要指定线程执行结果的返回值类型

运行步骤:
1.创建目标对象
2.通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象

例如:没有接收线程返回值的操作

package com.wangxing.test3;
import java.util.concurrent.Callable;
public class MyThread implements Callable{
	@Override
	public Object call() throws Exception {
		for(int i=1;i<=100;i++){
			//得到当前正在运行的线程名称
			//1.得到当前正在运行的线程对象
			Thread  dangqianObj=Thread.currentThread();
			//2.得到线程名称
			String name=dangqianObj.getName();
			System.out.println(name+"---i=="+i);
		}
		return null;
	}
}

package com.wangxing.test3;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
public class TestMain {
	public static void main(String[] args) {
		//启动线程---strat方法---Thread类---MyThread类与Thread类联系起来
		//创建目标对象
		MyThread  mt=new MyThread();
		//通过Future接口的子类FutureTask的构造方法
		//public FutureTask(Callable<V> callable)
		//将目标对象转换成Future接口的子类FutureTask对象
		//FutureTask类实现类RunnableFuture<V>接口
		//RunnableFuture<V>接口又继承了Runnable接口
		FutureTask  futruetask1=new FutureTask(mt);
		FutureTask  futruetask2=new FutureTask(mt);
		//通过Thread类的构造方法
		//public Thread(Runnable target)
		//将Runnable接口转换成课Thread类对象
		Thread  th1=new Thread(futruetask1);
		Thread  th2=new Thread(futruetask2);
		th1.start();
		th2.start();
	}
}

例如:接收线程返回值的操作

package com.wangxing.test4;
import java.util.concurrent.Callable;
public class MyThreadClass implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		int i=1;
		int sum=0;
		while(i<=100){
			//得到当前正在运行的线程名称
			//1.得到当前正在运行的线程对象
			Thread  dangqianObj=Thread.currentThread();
			//2.得到线程名称
			String name=dangqianObj.getName();
			System.out.println(name+"---i=="+i);
			sum=sum+i;
			i++;
		}
		return sum;
	}
}

package com.wangxing.test4;
import java.util.concurrent.FutureTask;
public class TestMain {
	public static void main(String[] args)throws Exception {
		//创建目标对象
		MyThreadClass  mtc=new MyThreadClass();
		//创建FutureTask对象
		FutureTask  futureTask1=new FutureTask(mtc);
		FutureTask  futureTask2=new FutureTask(mtc);
		//创建线程对象
		Thread th1=new Thread(futureTask1);
		Thread th2=new Thread(futureTask2);
		//启动线程
		th1.start();
		th2.start();
		//得到线程的运行结果
		//Future接口的get方法
		//FutureTask类是Future接口的字节,get方法被FutureTask类继承
		//FutureTask类的get方法得到线程的执行结果
		Object  obj1=futureTask1.get();
		int thres1=(Integer)obj1;
		System.out.println("线程1的运行结果=="+thres1);
		Object  obj2=futureTask2.get();
		int thres2=(Integer)obj2;
		System.out.println("线程2的运行结果=="+thres2);
	}
}

第四种,通过线程池创建多线程【使用的比较少,所以不强调】

多线程的创建方式的区别

继承Thread类
    1.创建新类继承Thread类重写run方法
    2.run方法没有返回值,不能声明抛出异常
    3.创建Thread类的子类对象【线程对象】,通过子类对象调用start方法启动线程
    4.无法资源共享
    5.不考虑资源共享时

实现Runnable接口
    1.创建新类实现Runnable接口重写run方法
    2.run方法没有返回值,不能声明抛出异常
    3.创建实现Runnable接口的子类对象【目标对象】,通过Thread的构造方法将目标对象转换成线程对象,通过线程对象调用start方法启动线程
    4.可以资源共享
    5.考虑资源共享时

Callable和Future接口
    1.创建新类实现Callable接口重写call方法,注意Callable接口的泛型类型[返回值类型]
    2.call方法有返回值,通过Future接口提供的get方法得到返回值,可以声明抛出异常
    3.创建实现Callable接口的子类对象【目标对象】,通过Future接口的子类FutureTask将Callable接口的子类转换成Runnable接口类型,通过Thread的构造方法将Runnable接口类型对象转换成线程对象,通过线程对象调用start方法启动线程。
    4.可以资源共享
    5.考虑资源共享时,异步编程

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值