@程序员,如何花式构建线程?

作者 | 曾建

责编 | 郭芮

出品 | CSDN(ID:CSDNnews)

在项目和业务的开发中,我们难免要经常使用线程来进行业务处理,使用线程可以保证我们的业务在相互处理之间可以保证原子性,减少相互之间的耦合和影响。通常情况下,我们会使用创建一个继承Thread的对象或实现Runnable接口的类来创建线程,我们很少会注意如何创建线程更简洁,更方便,更能提高开发效率,其实创建线程的方式有很多种,下面就来感受一下创建线程这个操作所拥有的魅力。

Java中创建线程主要有三种方式,我们先来看下第一种方式,通过继承Thread类创建线程类。该方式创建线程有3个步骤:

  • 定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

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

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

package com.test.thread;
public class ThreadTest extends Thread{
    /**
     * 需要手动重写run方法,run方法内为线程执行体
     */
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 100; i++) {
            if(i==20){
                new ThreadTest().start();
                new ThreadTest().start();
            }
        }
    }
}

这种方式创建线程也是最基本和最常用的方式,上述代码中Thread.currentThread()方法返回当前正在执行的线程对象,getName()方法返回调用该方法的线程的名字。

在实际应用过程中,我们经常会使用匿名内部类的方式在方法或代码块中创建线程,其示例如下:

public class ThreadTest2 {  
  public static void main(String[] args) {  
            new Thread() {  
                public void run() {  
                    while (true) {  
                        try {  
                            System.out.println("线程输出");  
                            //休眠两秒  
                            Thread.sleep(2 * 1000);  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                };  
            }.start();  
        }  
    } 

这种方式使用了匿名内部类的方式创建线程,在代码块中就可以直接创建线程,从而进行业务处理。这种方式也减少了创建线程类的步骤,直接就可以使用,提高了创建线程的灵活性。

第二种创建线程的主要方式为通过实现Runnable接口创建线程类,该方式创建线程主要有以下3个步骤:

  • 定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

  • 创建Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

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

package com.test.thread;
public class RunnableThreadTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 100; i++) {
            if(i==20){
                RunnableThreadTest test = new RunnableThreadTest();
                Thread thread1 = new Thread(test);
                Thread thread2 = new Thread(test);
                thread1.start();
                thread2.start();
            }
        }
    }
}

通过实现Runnable接口创建线程类时,我们需要将该线程类的对象作为Thread类的传参,然后才可以创建对象,因为Thread类的底层封装了一个Runnable接口为参数的构造函数,然后调用Thread类的start()方法开始执行线程内的方法体,Runnable接口为参数的构造函数其代码如下,可以感受一番:

  public Thread(Runnable target) {
          // 该方法为Thread类中初始化加载线程的方法
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

第三种创建线程的方式主要是通过Callable和Future创建线程。

从继承Thread类和实现Runnable接口可以看出,上述两种方法都不能有返回值,且不能声明抛出异常。而Callable接口则实现了此两点,Callable接口如同Runnable接口的升级版,其提供的call()方法将作为线程的执行体,同时允许有返回值。

但是Callable对象不能直接作为Thread对象的target,不是Runnable接口的子接口。对于这个问题的解决方案,就引入了Future接口,此接口可以接受call()的返回值,RubbaleFuture接口是Future接口和Runnable接口的子接口,可以作为Thread对象的target。并且,Future接口提供了一个实现类:FutureTask。FutureTask实现了RunnableFuture接口,可以作为Thread对象的target。

通过Callable和Future创建线程主要有以下四个步骤:

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

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

  • 使用FutureTask对象作为Thread对象的target创建并启动新线程。

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

package com.test.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int i=0;
        for (; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
        return i;
    }

    public static void main(String[] args) {
        CallableThreadTest thredClass = new CallableThreadTest();
        FutureTask<Integer> future = new FutureTask<>(thredClass);
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
            if(i==2){
                new Thread(future).start();
            }
        }
        try {
            future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    }

上述示例是通过实现Callable接口的普通类来创建线程,通过上述示例我们不仅可以进行异常抛出,还可以手动获取线程的返回值。在实际的应用过程中,我们会经常通过匿名内部类在方法或代码块中创建线程,示例如下:

package com.test;
import java.util.concurrent.FutureTask;
import java.util.concurrent.Callable;

public class FutureThread {
    public static void main(String[] args) {
        FutureTask<Integer> future = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return 2+3;
            }
        });
        Thread futurerThread = new Thread(future);
        futurerThread.start();      
    }   
}

当我们通过FutureTask类来创建实例对象时,我们会发现FutureTask的泛型参数是一个必填参数,我们可以打开FutureTask的底层会发现,FutureTask类有两个构造函数,其底层构造代码如下:

  /**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Callable}.
     *
     * @param  callable the callable task
     * @throws NullPointerException if the callable is null
     */
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    /**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Runnable}, and arrange that {@code get} will return the
     * given result on successful completion.
     *
     * @param runnable the runnable task
     * @param result the result to return on successful completion. If
     * you don't need a particular result, consider using
     * constructions of the form:
     * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
     * @throws NullPointerException if the runnable is null
     */
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

第一个构造是通过传入一个Callable的对象创建线程,Callable对象会自动执行call()方法,第二个构造是通过传入一个实现Runnable的对象创建线程,后面有一个result参数,其用来返回线程执行的成功失败的状态。所以我们可以通过以上两种构造方式来创建FutureTask对象,然后将其作为Thread对象的target创建并启动新线程。

当我们了解Java8的时候,你会发现上面创建线程的方式其实是很复杂的。Java8提供了函数式接口编程,函数式接口编程极简化了线程的创建方式,增强了代码的可读性。什么是函数式接口编程呢?jdk8引入的lambda表达式和Stream为Java平台提供了函数式编程的支持,极大的提高了开发效率。

函数式编程针对为函数式接口而言,函数式接口是有且只有一个抽象方法的接口。Lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现,并把整个表达式作为函数式接口的实例。当我们把一个Lambda表达式赋给一个函数式接口时,这个表达式对应的必定是接口中唯一的抽象方法。因此就不需要以匿名类那么繁琐的形式去实现这个接口。可以说在语法简化上,Lambda表达式完成了方法层面的简化,函数式接口完成了类层面的简化。

函数式编程接口都只有一个抽象方法,编译器会将函数编译后当做该抽象方法的实现。如果接口有多个抽象方法,编译器就不知道这段函数应该是实现哪个方法了。例如:

以Callable接口作为示例,它是一个函数式接口,包含一个抽象方法call()。现在要定义一个Callable对象,传统方式是这样的:

    Callable c = new Callable() {
        @Override
        public Object call() throws Exception {
            int resultCode = 200;
            return resultCode;
        }
    };

而使用函数式编程,可以这样定义:

    Consumer c = (o) -> {
        System.out.println(o);
    }; 

通过了解函数式编程接口之后我们发现通过函数式接口可以极大简化代码和开发效率。当我们在创建线程的时候也可以使用函数式编程接口的方法来创建线程。

示例如下:

package com.test.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 
 * 〈java8 流式创建线程〉<br> 
 * 〈功能详细描述〉
 *
 * @author zengjian
 */
public class ThreadStreamTest {
    public static void main(String[] args) {
         try {
              FutureTask<Integer> task = new FutureTask<Integer>(()->threadMethod());
              Thread taskThread = new Thread(task);
              taskThread.start();
              Integer result = task.get();
              System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public static int threadMethod(){
        return 2+4;
    }
}

通过示例我们会发现,通过函数式编程的方式,极大的简化了创建线程的代码,可以有效的提高代码的可读性和维护性,所以在开发的过程中可以经常使用这种方式进行创建线程,提高我们的开发效率。

FutureTask是为了弥补Thread的不足而设计的,他可以让程序员准确地知道线程什么时候执行完成并获得到线程执行完成后返回的结果。FutureTask是一种可以取消的异步的计算任务。它的计算是通过Callable实现的,它等价于可以携带结果的Runnable,并且有三个状态:等待、运行和完成。完成包括所有计算以任意的方式结束,包括正常结束、取消和异常。Executor框架利用FutureTask来完成异步任务,并可以用来进行任何潜在的耗时的计算。一般FutureTask多用于耗时的计算,主线程可以在完成自己的任务后,再去获取结果。在多线程高并发的场景下用途比较广泛,可以处理多任务异步处理等。

线程知识丰富且复杂,通了解创建线程的这一操作,可以帮助我们理解线程相关的知识和细节,也可以帮忙我们理解在应用过程中多线程和高并发相关的知识。通过这篇文章,希望对你有所帮助哦。

作者:曾建,目前就职于苏宁易购,专注于CDN相关系统开发。

你点的每个“在看”,我都认真当成了喜欢

发布了1726 篇原创文章 · 获赞 4万+ · 访问量 1552万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 代码科技 设计师: Amelia_0503

分享到微信朋友圈

×

扫一扫,手机浏览