线程基础总结

最新推荐文章于 2022-08-29 11:30:32 发布

卓小白…

最新推荐文章于 2022-08-29 11:30:32 发布

阅读量222

点赞数 1

文章标签：多线程 java

本文链接：https://blog.youkuaiyun.com/weixin_45075135/article/details/113926139

版权

本文详细介绍了Java中创建线程的三种方式：继承Thread类、实现Runnable接口和实现Callable接口。通过实例分析了线程的执行过程，探讨了线程之间的资源共享和线程安全问题。同时，对比了三种方式的优缺点，指出在实际开发中通常推荐使用实现Runnable接口的方式来创建线程，以避免类的单继承限制并提高代码复用性。

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

一、线程和进程

1.进程

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

2.线程

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

线程是一条可以执行的路径。多线程就是同时有多条执行路径在同时(并行)执行。

3.进程和线程的关系

一个程序就是一个进程，而一个程序中的多个任务则被称为线程。进程是表示资源分配的基本单位，又是调度运行的基本单位。，亦即执行处理机调度的基本单位。进程和线程的关系：

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量，即每个线程都有自己的堆栈和局部变量。
处理机分给线程，即真正在处理机上运行的是线程。
线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

如果把上课的过程比作进程，把老师比作CPU，那么可以把每个学生比作每个线程，所有学生共享这个教室(也就是所有线程共享进程的资源)，上课时学生A向老师提出问题，老师对A进行解答，此时可能会有学生B对老师的解答不懂会提出B的疑问(注意：此时可能老师还没有对A同学的问题解答完毕)，此时老师又向学生B解惑，解释完之后又继续回答学生A的问题，同一时刻老师只能向一个学生回答问题(即：当多个线程在运行时，同一个CPU在某一个时刻只能服务于一个线程，可能一个线程分配一点时间，时间到了就轮到其它线程执行了，这样多个线程在来回的切换)

二、线程的创建

继承 Thread
实现 Runable
实现 Callable

1. 通过继承Thread类创建线程类

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

定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；
创建该类的实例对象，即创建了线程对象；
调用线程对象的start()方法来启动线程；

代码实例：


public class ExtendThread extends Thread {
 
	private int i;
	
	public static void main(String[] args) {
		for(int j = 0;j < 50;j++) {
			
			//调用Thread类的currentThread()方法获取当前线程
			System.out.println(Thread.currentThread().getName() + " " + j);
			
			if(j == 10) {
				//创建并启动第一个线程
				new ExtendThread().start();
				
				//创建并启动第二个线程
				new ExtendThread().start();
			}
		}
	}
 
	public void run() {
		for(;i < 100;i++) {
			//当通过继承Thread类的方式实现多线程时，可以直接使用this获取当前执行的线程
			System.out.println(this.getName() + " "  + i);
		}
	}

代码相关：

上述的getName()方法是返回当前线程的名字，也可以通过setName()方法设置当前线程的名字；
当JAVA程序运行后，程序至少会创建一个主线程（自动），主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的；
在默认情况下，主线程的线程名字为main，用户创建的线程依次为Thread—1、Thread—2、…、Thread—3；

代码分析：
在这里插入图片描述
这是代码运行后的截图，从图中可以看出：

有三个线程：main、Thread-0 、Thread-1
Thread-0 、Thread-1两个线程输出的成员变量 i 的值不连续（这里的 i
是实例变量而不是局部变量）。因为：通过继承Thread类实现多线程时，每个线程的创建都要创建不同的子类对象，导致Thread-0、Thread-1两个线程不能共享成员变量 i ；
线程的执行是抢占式，并没有说Thread-0 或者Thread-1一直占用CPU（这也与线程优先级有关，这里Thread-0、Thread-1线程优先级相同，关于线程优先级的知识这里不做展开）；

2.通过实现Runnable接口创建线程类

这种方式创建并启动多线程的步骤如下：

定义一个类实现Runnable接口；
创建该类的实例对象obj；
将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；
调用线程对象的start()方法启动该线程；

代码实例：`

public class ImpRunnable implements Runnable {
	
	private int i;
	
	@Override
	public  void run() {
		for(;i < 50;i++) {	
			//当线程类实现Runnable接口时，要获取当前线程对象只有通过Thread.currentThread()获取
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
 
	public static void main(String[] args) {
		for(int j = 0;j < 30;j++) {
			System.out.println(Thread.currentThread().getName() + " " + j);
			if(j == 10) {
				ImpRunnable thread_target = new ImpRunnable();
				//通过new Thread(target,name)的方式创建线程
				new Thread(thread_target,"线程1").start();
				new Thread(thread_target,"线程2").start();
			}			
		} 
	} 
）

代码相关：

实现Runnable接口的类的实例对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅仅作为线程执行体，而实际的线程对象依然是Thread实例，这里的Thread实例负责执行其target的run()方法；
通过实现Runnable接口来实现多线程时，要获取当前线程对象只能通过Thread.currentThread()方法，而不能通过this关键字获取；
从JAVA8开始，Runnable接口使用了@FunctionlInterface修饰，也就是说Runnable接口是函数式接口，可使用lambda表达式创建对象，使用lambda表达式就可以不像上述代码一样还要创建一个实现Runnable接口的类，然后再创建类的实例。

在这里插入图片描述

这是代码运行后的结果截图，从图中可以看出：

1、线程1和线程2输出的成员变量i是连续的，也就是说通过这种方式创建线程，可以使多线程共享线程类的实例变量，因为这里的多个线程都使用了同一个target实例变量。但是，当你使用我上述的代码运行的时候，你会发现，其实结果有些并不连续，这是因为多个线程访问同一资源时，如果资源没有加锁，那么会出现线程安全问题（这是
线程同步的知识，这里不展开）；

3.通过Callable和Future接口创建线程

通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体，那么，是否可以直接把任意方法都包装成线程的执行体呢？从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：

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

从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。但问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取call()方法返回值的问题。

于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为Thread类的target这一问题。

在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务：

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

这种方式创建并启动多线程的步骤如下：

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

public class ThirdThreadImp {
	
	public static void main(String[] args) {
		
		//这里call()方法的重写是采用lambda表达式，没有新建一个Callable接口的实现类
		FutureTask<Integer> task =  new FutureTask<Integer>((Callable<Integer>)()->{
			int i = 0;
			for(;i < 50;i++) {
				System.out.println(Thread.currentThread().getName() + 
						"  的线程执行体内的循环变量i的值为：" + i);	
			}
			//call()方法的返回值
			return i;
		});
		
		for(int j = 0;j < 50;j++) {
			System.out.println(Thread.currentThread().getName() + 
					" 大循环的循环变量j的值为：" + j);
			if(j == 20) {
				new Thread(task,"有返回值的线程").start();
			}
		}
		try {
			System.out.println("子线程的返回值：" + task.get());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 }