Java线程的创建和启动

Java使用Thread类代表线程,所有线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段程序流(一段顺序执行的代码)。Java使用线程执行体来代表这段程序流。

一、继承Thread类创建线程类

通过继承Thread类来创建并启动多线程的步骤如下。
定义Thread类的子类,并重写改类的run()方法,该run()方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

创建Thread子类的实例,即创建了线程对象。

调用线程对象的start()方法来启动该线程。

下面程序示范了通过几次Thread类来创建并启动多线程。

public class FirstThread extends Thread{

    private int i;
    //重写run()方法,run()方法的方法体就是线程执行体
    public void run()
    {
        for( ; i < 100 ;i++)
        {
            //当线程几次Thread类时,直接使用this即可获取当前线程
            //Thread对象的getName()返回当前线程的名字
            //因此可以直接调用getName()方法返回当前线程的名字
            System.out.println(getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        for(int i = 0;i < 100;i++)
        {
            //调用Thread的currentThrean()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if(i == 20)
            {
                //创建并启动第一个线程
                new FirstThread().start();
                //创建并启动第二个线程
                new FirstThread().start();
            }
        }
    }
}

上面程序中的FirstThread类几次了Thread类,并实现了run()方法,该run()方法里的代码执行流程就是该线程需要完成的任务。程序的主方法体中也包含了一个循环,当循环变量i 等于20是创建并启动两个新线程。

虽然该程序创建并启动了2个线程,但实际上有3个线程,即程序显式创建的2个子线程和主线程。

除此之外,上面程序中还用到了线程的如下两个方法。

  • Thread.currentThread():currentThread()是Thread类的静态方法,该方法总是返回当前正在执行的线程对象。
  • getName():该方法时Thread类的实例方法,该方法返回调用该方法的线程名字。

提示:程序可通过setName(String name)方法为线程设置名字,也可通过getName()方法返回指定线程的名字。在默认 情况下,主线程的名字为main,用户启动的多个线程的名字依次为Thread-0、Thread-1、Thread-1、Thread-2、…、Thread-n等

如果运行上面的程序,可以看出,Thread-0和Thread-1两个线程输出的i变量不连续——注意:i变量是FirstThread的实例变量,而不是局部变量。但因为程序每次创建线程对象时都需要创建一个FirstThread对象,所以Thread-0和Thread-1不能共享该实例变量。

注意:使用继承Thread类的方法来创建线程类时,多个线程之间无法共享线程类的实例变量。

二、实现Runnable接口创建线程类

实现Runnable接口来创建并启动线程的步骤如下。
定义Runnable接口的实现类,并重写改接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。代码如下所示。

//创建Runnable实现类的对象
SecondThread st = new SecondThread();
//以Runnable实现类的对象作为Thread的target来创建Thread对象,即线程对象
new Thread(st);

也可以在创建Thread对象时为该Thread对象指定一个名字。如下所示。

//创建Thread对象时指定target和新线程的名字
new Thread(st,"新线程1");

③调用线程对象的start()方法启动该线程。

提示:
Runnable对象仅仅作为Thread的target,Runnable实现类里包含的run()方法作为线程执行体。而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。

下面程序示范了通过实现Runnable接口来创建并启动多线程。

public class SecondThread implements Runnable{
    private int i;
    //run()方法同样是线程执行体
    public void run()
    {
        for( ; i < 100;i++)
        {
            //当线程类实现Runnable接口时
            //如果想获取当前线程,只能用Thread.currentThread()方法
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args)
    {
        for(int i = 0; i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName() + " " + i);

            if(i == 20)
            {
                SecondThread st = new SecondThread();//①
                //通过new Thread(target , name)方法创建新线程
                new Thread(st , "新线程1").start();
                new Thread(st , "新线程2").start();
            }
        }
    }
}

上面程序中的粗体字代码部分实现了run()方法,也就是定义了该线程的线程执行体。对比FirstThread中的run()方法体和SecondThread中的run()方法体不难发现,通过继承Thread类来获得当前线程对象比较简单,直接使用this就可以了;但通过实现Runnable接口来获得当前线程对象,则必须使用Thread.currentThread()方法。

提示:
Runnable接口中只包含一个抽象方法,从Java 8开始,Runnable接口使用了@FunctionalInterface修饰。也就是说,Runnable是函数式接口,可以使用Lambda表达式创建Runnable接口。接下来介绍的Callable接口也是函数式接口。

除此以外,上面程序中的粗体字代码创建了两个Thread对象,并调用start()方法来启动这两个线程。在FirstThread和SecondThread中创建线程对象的方式有所区别:前者直接创建的Thread子类即可代表线程对象;后这创建的Runnable对象只能作为线程对象的target。

从图中两个灰色覆盖区域可以看出,两个子线程的变量是连续的,也就是采用Runnable接口的方式创建的多个线程可以共享线程类的实例变量。这是因为在这种方式下,程序所创建的对象只是线程的target,而多个线程可以共享同一个target,而多个线程可以共享同一个线程类(实际上应该是线程的target)的实例变量。

三、使用Callable和Future创建线程

前面已经指出,通过实现Runnable接口创建多线程,Thread的作用就是把run()方法包装成线程执行体,那么是否可以直接把任意方法都包装成线程执行体呢?Java目前还不行,但是C#可以(C#可以把任意方法包装成线程执行体,包括有返回值的方法)。

也许受此启发,从Java 5开始,Java提供了Callable接口,该接口像是Runnable接口的增强版,Callable接口提供了一个call()方法可以作为线程的执行体,但call()方法比run()方法功能更强大。

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

因此完全可以提供一个Callable对象作为Thread的target,而该线程的线程执行体就是该Callable对象的call()方法。问题是:Callable接口时Java 5新增的接口,而且它不是Runnable接口的子接口,所以Callable对象不能直接作为Thread的target。而且call()方法还有一个返回值——call()方法并不是直接调用,它是作为线程的执行体被调用的。那么如何获取call()方法的返回值呢?

Java 5提供了Future接口来代表Callable接口里call()方法的返回值,并为Future接口提供了一个FutureTask实现类,该实现类实现了Future接口,并实现了Runnable接口——可以作为Thread的target

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

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

注意:Callable接口有泛型限制,Callable接口里的泛型形参类型与call()方法返回值类型相同。而且Callable接口是函数式接口,因此可用Lambda表达式创建Callable对象。

创建并启动有返回值的线程的步骤如下。

  1. 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,且该call()方法有返回值,再创建Callable实现类的实例。从Java 8开始,可用直接使用Lambda表达式创建Callable对象。
  2. 使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值
  3. 使用FutureTask对象作为Thread对象的target创建并启动新线程
  4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

下面通过程序实现Callable对象来实现线程类,并启动该线程。

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

public class ThirdThread {
    public static void main(String[] args) {
        //创建Callable对象
        ThirdThread rt = new ThirdThread();

        //先使用Lambda表达式创建Callable<Integer>对象
        //使用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>) () ->{
            int i = 0;
            for( ;i < 100;i++)
            {
                System.out.println(Thread.currentThread().getName() 
                        + " 的循环变量i的值:" + i);
            }
            //call()方法可以有返回值
            return i;
        });

        for(int i = 0; i < 100 ; i++)
        {
            System.out.println(Thread.currentThread().getName()
                    + " 的循环变量i的值: " + i );
            if(i == 20)
            {
                //实质还是以Callable对象来创建并启动的
                new Thread(task, "有返回值的线程").start();
            }
        }
        try
        {
            //获取返线程返回值
            System.out.println("子线程的返回值:" + task.get());
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
} 

上面程序使用了Lambda表达式直接创建了Callable对象,这样无须先创建Callable实现类,再创建Callable对象了。实现Callable接口与实现Runnable接口并没有太大的差别,只是Callable的call()方法允许声明抛出异常,而且允许带返回值。

上面程序中的粗体字代码是以Callable对象来启动线程的关键代码。程序先用Lambda表达式创建了一个Callable对象,然后将该实例包装成一个FutureTask对象。程序最后使用调用FutureTask的get()方法来返回call()方法的返回值——该方法将导致程序被阻塞,知道call()方法结束并返回为止。

四、创建线程的三种方式对比

通过继承Thread类或实现Runnable、Callable接口都可以实现多线程,不过实现Runnable接口与实现Callable接口方式基本相同,只是Callable接口里定义的方法有返回值,可以声明抛出异常而已。因此可以将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式之间的主要差别如下。

采用实现Runnable、Callable接口的方式创建多线程的优缺点:

  1. 线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
  2. 在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

劣势是:
1. 编程稍稍复杂,如果需要访问当前线程,则必须使用Thread.currentThread()方法。

采用继承Thread()类的方式创建多线程的优缺点:
劣势是:线程已经继承了Thread类,不能再继承其他父类。

优势是:编程简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。

基于上面分析,因此一般推荐采用Runnable接口、Callable接口的方式来创建多线程

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值