RELATEED CONSULTING
相关咨询
选择下列产品马上在线沟通
服务时间:8:30-17:00
你可能遇到了下面的问题
关闭右侧工具栏

新闻中心

这里有您想知道的互联网营销解决方案
实现Java线程的方法有哪些

这篇文章主要介绍“实现Java线程的方法有哪些”,在日常操作中,相信很多人在实现Java线程的方法有哪些问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”实现Java线程的方法有哪些”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

成都创新互联是一家专注于成都网站建设、成都做网站与策划设计,京口网站建设哪家好?成都创新互联做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:京口等地区。京口做网站价格咨询:18982081108

搞懂两件事: 为什么说本质上只有一种实现线程的方式? 实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里?

一:常见的实现线程的方式

1:实现Runable接口

public class RunnableThread  implements Runnable{
    @Override
    public void run() {
        System.out.println("用实现Runnable接口实现线程");
    }
    public static void main(String[] args) {
        Thread thread=new Thread(new RunnableThread());
        thread.start();
    }
}

如代码所示,首先通过 RunnableThread 类实现 Runnable 接口,然后重写 run() 方法,之后只需要把这个实现了 run() 方法的实例传到 Thread 类中就可以实现多线程。

2:继承Thread类

public class ExtendsThread extends Thread{
    @Override
    public void run() {
        System.out.println("用继承Thread类实现线程");
    }
}

与第 1 种方式不同的是它没有实现接口,而是继承 Thread 类,并重写了其中的 run() 方法。

3:线程池创建线程

下面是线程池中的源码,来看看线程池是怎么实现线程的:

    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

对于线程池而言,本质上是通过线程工厂创建线程的,默认采用 DefaultThreadFactory,它会给线程池创建的线程设置一些默认值,比如:线程的名字、是否是守护线程,以及线程的优先级等。但是最终都是通过new Thread()创建线程的,只是参数多了些而已

4:有返回值的 Callable 创建线程

public class CallableTask implements Callable {
    @Override
    public Integer call() throws Exception {
        return new Random().nextInt();
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future future = executorService.submit(new CallableTask());
        System.out.println(future.get());
        System.out.println(future.isDone());
        System.out.println(future.isCancelled());
    }
}

Runnable 创建线程是无返回值的,而 Callable 和与之相关的 Future、FutureTask,它们可以把线程执行的结果作为返回值返回,如代码所示,实现了 Callable 接口,并且给它的泛型设置成 Integer,然后它会返回一个随机数。

但是,无论是 Callable 还是 FutureTask,它们首先和 Runnable 一样,都是一个任务,是需要被执行的,而不是说它们本身就是线程。它们可以放到线程池中执行,如代码所示, submit() 方法把任务放到线程池中,并由线程池创建线程,不管用什么方法,最终都是靠线程来执行的,而子线程的创建方式仍脱离不了最开始讲的两种基本方式,也就是实现 Runnable 接口和继承 Thread 类

5:匿名内部类、lambda表达式创建线程

    public static void innerClassThread(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建线程");
            }
        }).start();
    }

    public static void lambdaThread(){
       new Thread(()->{
           System.out.println("lambda表达式创建线程");
       }).start();
    }

实际上,匿名内部类或 lambda 表达式创建线程,它们仅仅是在语法层面上实现了线程,并不能把它归结于实现多线程的方式,如匿名内部类实现线程的代码所示,它仅仅是用一个匿名内部类把需要传入的 Runnable 给实例出来。

二:为什么说本质上只有一种实现线程的方式?

了解了上面的几种创建线程的方式后,我们发现所有其他创建线程的方式都仅仅是在 new Thread() 外做了一层封装而已;不同点仅仅在于实现线程运行内容的不同。

  1. 实现线程执行的内容,通过实现 Runnable 接口的方式

启动线程需要调用 start() 方法,而 start() 方法最终还会调用 run() 方法,Thread中的run()方法源码如下:

    /* What will be run. */
    private Runnable target;
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
  • target其实就是一个Runnable,实际线程执行的内容就是实现了Runnable的接口中的run方法。

  1. 实现线程执行的内容,继承 Thread 类重写 run() 方法的方式

  • 启动线程需要调用 start() 方法,而 start() 方法最终还会调用 run() 方法,但是此时的run()方法,因为继承的原因,此时已被子类重写了,所以此时线程执行的内容是子类的run方法

运行内容主要来自于两个地方,要么来自于 target,要么来自于子类重写的 run() 方法;因此可以这样总结:本质上,实现线程只有一种方式new Thread(),而要想实现线程执行的内容,却有两种方式,要么通过实现 Runnable 接口的方式,要么继承 Thread 类重写 run() 方法的方式,把我们想要执行的代码传入,让线程去执行

三:实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里?

  1. Runnable 里只有一个 run() 方法,它定义了需要执行的内容,在这种情况下,实现了 Runnable 与 Thread 类的解耦,Thread 类负责线程启动和属性设置等内容,职责分明。

  2. java单继承的原因,类一旦继承了 Thread 类,那么它后续就没有办法再继承其他的类,限制了代码未来的可拓展性。

  3. 在某些情况下可以提高性能,如果使用继承 Thread 类方式,每次执行一次任务,都需要新建一个独立的线程;使用实现 Runnable 接口的方式,就可以把任务直接传入线程池,使用一些固定的线程来完成任务,不需要每次新建销毁线程,大大降低了性能开销。

到此,关于“实现Java线程的方法有哪些”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注创新互联网站,小编会继续努力为大家带来更多实用的文章!


网站题目:实现Java线程的方法有哪些
标题链接:http://lswzjz.com/article/pchsge.html