JAVA多线程的三种创建方式

一、概述

    在JAVA中,用Thread类代表线程,所有线程对象,都必须是Thread类或者Thread类子类的实例。每个线程的任务就是执行一段顺序执行的代码,JAVA使用线程执行体来容纳这段代码。所以,我们创建线程时,主要是根据实际需求,编写放入线程执行体的代码。

二、三种创建方式

2.1  第一种,通过继承Thread类创建线程类

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

1、定义一个类继承Thread类,并重写Thread类的run()方法,run()方法的方法体就是线程要完成的任务,因此把run()称为线程的执行体;

2、创建该类的实例对象,即创建了线程对象;

3、调用线程对象的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);
		}
	}
}

代码相关:

1、上述的getName()方法是返回当前线程的名字,也可以通过setName()方法设置当前线程的名字

2、当JAVA程序运行后,程序至少会创建一个主线程(自动)主线程的线程执行体不是由run()方法确定的,而是由main()方法确定的;

3、在默认情况下,主线程的线程名字为main,用户创建的线程依次为Thread—1、Thread—2、....、Thread—3;

代码分析:

这是代码运行后的截图,从图中可以看出:

1、有三个线程:main、Thread-0 、Thread-1

2、Thread-0 、Thread-1两个线程输出的成员变量 i 的值不连续(这里的 i 是实例变量而不是局部变量)。因为:通过继承Thread类实现多线程时,每个线程的创建都要创建不同的子类对象,导致Thread-0 、Thread-1两个线程不能共享成员变量 i 

3、线程的执行是抢占式,并没有说Thread-0 或者Thread-1一直占用CPU(这也与线程优先级有关,这里Thread-0 、Thread-1线程优先级相同,关于线程优先级的知识这里不做展开);

2.2  第二种,通过实现Runnable接口创建线程类

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

1、定义一个类实现Runnable接口;

2、创建该类的实例对象obj;

3、将obj作为构造器参数传入Thread类实例对象,这个对象才是真正的线程对象;

4、调用线程对象的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();
			}
			
		}

	}

}

代码相关:

1、实现Runnable接口的类的实例对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅仅作为线程执行体,而实际的线程对象依然是Thread实例,这里的Thread实例负责执行其target的run()方法

2、通过实现Runnable接口来实现多线程时,要获取当前线程对象只能通过Thread.currentThread()方法,而不能通过this关键字获取;

3、从JAVA8开始,Runnable接口使用了@FunctionlInterface修饰,也就是说Runnable接口是函数式接口,可使用lambda表达式创建对象,使用lambda表达式就可以不像上述代码一样还要创建一个实现Runnable接口的类,然后再创建类的实例。

代码分析:

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

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

2.3  第三种,通过Callable和Future接口创建线程

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

1、call()方法可以有返回值;

2、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任务:

1、boolean cancel(boolean mayInterruptIfRunning):试图取消Future里关联的Callable任务;

2、V get():返回Callable任务里call()方法的返回值,调用该方法将导致程序阻塞,必须等到子线程结束以后才会得到返回值;

3、V get(long timeout, TimeUnit unit):返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间,如果经过指定时间后,Callable任务依然没有返回值,将会抛出TimeoutException异常;

4、boolean isCancelled():如果Callable任务正常完成前被取消,则返回true;

5、boolean isDone():如果Callable任务已经完成, 则返回true;

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

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

2、使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值;

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

4、调用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();
		}
	}

}

代码相关:

1、上述代码没有使用创建一个实现Callable接口的类,然后创建一个实现类实例的做法。因为,从JAVA8开始可以直接使用Lambda表达式创建Callable对象,所以上面的代码使用了Lambda表达式;

2、call()方法的返回值类型与创建FutureTask对象时<>里的类型一致。

代码分析:

这里就不过多的分析,只看最后一行输出可知:调用FutureTask对象的get()方法,必须等到子线程结束以后,才会有返回值。

三、三种创建方式对比

     上面已经介绍完了JAVA中创建线程的三种方法,通过对比我们可以知道,JAVA实现多线程可以分为两类:一类是继承Thread类实现多线程;另一类是:通过实现Runnable接口或者Callable接口实现多线程。

下面我们来分析一下这两类实现多线程的方式的优劣:

通过继承Thread类实现多线程:

优点:

1、实现起来简单,而且要获取当前线程,无需调用Thread.currentThread()方法,直接使用this即可获取当前线程;

缺点:

1、线程类已经继承Thread类了,就不能再继承其他类;

2、多个线程不能共享同一份资源(如前面分析的成员变量 i );

通过实现Runnable接口或者Callable接口实现多线程:

优点:

1、线程类只是实现了接口,还可以继承其他类;

2、多个线程可以使用同一个target对象,适合多个线程处理同一份资源的情况。

缺点:

1、通过这种方式实现多线程,相较于第一类方式,编程较复杂;

2、要访问当前线程,必须调用Thread.currentThread()方法。

综上:

一般采用第二类方式实现多线程。

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页