Java多线程实现方式

原创 2018年04月16日 18:56:27

Java多线程实现方式

实现方式

    Java多线程共有四种不同的实现方式:分别为继承Thread类、实现Runnable接口,实现Callable接口
并通过FutureTask包装器创建线程,使用ExecutorService、Callable、Future实现多线程。
一、继承Thread类实现多线程
        Thread类本质上实现了Runnable接口,代表一个线程的实例。启动线程的唯一方法是调用类的start
    方法。start方法是一个native方法,它将启动一个新线程,并执行run方法。以这种方式实现多线程较为
    简单:首先定义自己的类,然后自己的类继承Thread类,并重写run()方法,调用start方法就可以启动一个
    新线程并执行run方法。示例如下:
    public class ThreadDemo extends Thread{
        public void run(){
            System.out.println("ThreadDemo start..");
        }

        public static void main(String[] args) {
            ThreadDemo td = new ThreadDemo();
            td.start();
        }
    }
二、实现Runnable接口实现多线程。示例如下:
    public class RunnableDemo implements Runnable{
        @Override
        public void run() {
            System.out.println("RunnableDemo start..");
        }

        public static void main(String[] args) {
            RunnableDemo rd = new RunnableDemo();
            Thread t = new Thread(rd);
            t.start();
        }
    }
三、实现Callable接口并通过FutureTask包装器创建线程。示例如下:
    public class CallableDemo{
        public static void main(String[] args) throws InterruptedException, ExecutionException {
            Callable<Integer> call = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("callable thread start..");
                    Thread.sleep(2000);
                    return 1;
                }
            };

            FutureTask<Integer> task = new FutureTask<>(call);
            Thread t =  new Thread(task);
            t.start();

            System.out.println("do other thing..");
            System.out.println("callable res=" + task.get());
        }
    }
四、使用ExecutorService、Callable、Future实现多线程。示例如下:
    public class ExecutorServiceDemo {
        public static void main(String[] args) throws InterruptedException, ExecutionException {
            System.out.println("main start..");
            int taskSize = 5;

            ExecutorService pool = Executors.newFixedThreadPool(taskSize);
            List<Future<Integer>> list = new ArrayList<Future<Integer>>();
            for (int i = 0; i < taskSize; i++) {
                Callable<Integer> c = new MyCallable<Integer>(i + " ");
                Future<Integer> f = pool.submit(c);
                list.add(f);
            }

            pool.shutdown();

            for (Future<Integer> f : list) {
                System.out.println("threads res=" + f.get());
            }
        }
    }

    class MyCallable<Integer> implements Callable<Integer> {
        private String taskNum;

        MyCallable(String taskNum) {
            this.taskNum = taskNum;
        }

        public Integer call() throws Exception {
            System.out.println("---" + taskNum + " thread start");
            Date dateStart = new Date();
            Thread.sleep(1000);
            Date dateEnd = new Date();
            long time = dateEnd.getTime() - dateStart.getTime();
            return (Integer) (taskNum + " end require[" + time + "ms]");
        }
    }

不同实现方式的差异

一、如果自己定义的类已经继承了其他类,由于java是单根继承,故只能通过实现接口实现多线程。
二、继承Thread类和实现Runnable接口实现多线程,没有返回值;实现Callable接口和利用ExecutorService
实现多线程可以有返回值,并封装与FutureTask和Future中,值得注意的是,获取返回值的get方法,是阻塞方法,
即必须等到线程执行结束才能得到返回值。
三、继承Thread类和实现Runnable接口实现多线程,不能抛出异常;实现Callable接口和利用ExecutorService
实现多线程,可以抛出异常。

java核心篇 第三章 反射、多线程

-
  • 1970年01月01日 08:00

java多线程的6种实现方式详解

多线程的实现方式继承Thread类万物皆对象,那么线程也是对象,对象就应该能够抽取其公共特性封装成为类,使用类可以实例化多个对象,那么实现线程的第一种方式就是继承Thread类的方式。继承Thread...
  • king_kgh
  • king_kgh
  • 2017-10-12 12:41:57
  • 1431

Java多线程的四种实现方式

 Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorSer...
  • a724888
  • a724888
  • 2017-04-10 21:53:54
  • 1635

Java多线程实现的四种方式

Java多线程实现的方式有四种 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target ...
  • u011480603
  • u011480603
  • 2017-07-19 01:45:07
  • 10102

多线程——Java多线程实现的三种方式

实现多线程的几种方式,建议使用runable实现,不管如何最终都需要thread.start( )来启动线程。...
  • xdd19910505
  • xdd19910505
  • 2016-03-22 20:30:08
  • 8150

Java中两种多线程实现方式的区别

在程序开发中用到多线程,正统的方法是使用Runnable接口,相比继承Thread类,Runnable接口有以下两点好处: 1、避免单继承机制的局限,一个类可以实现多个接口 2、适用于资源的共享 下面...
  • june_ruikang
  • june_ruikang
  • 2016-02-26 21:00:10
  • 822

JAVA多线程实现的三种方式

JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没...
  • aboy123
  • aboy123
  • 2014-07-31 18:34:17
  • 458762

java多线程都有几种方式实现

有三种:     (1)继承Thread类,重写run函数         创建:         class xx extends Thread{ public void ...
  • hintcnuie
  • hintcnuie
  • 2013-09-04 14:08:00
  • 30637

java多线程实现的三种方式

java多线程实现方式主要是有三种:继承thread类,实现Runnable接口,使用ExecutorService,Callable,Future实现有返回结果的多线程,其中前两种方式线程执行完后都...
  • u014209975
  • u014209975
  • 2016-08-30 15:39:47
  • 1780

Java中实现多线程的两种方式之间的区别

【原文地址 点击打开链接】 原文地址:http://www.cnblogs.com/gw811/archive/2012/10/15/2724882.html  Java提供了线程类Thr...
  • wenyiqingnianiii
  • wenyiqingnianiii
  • 2016-10-04 15:09:04
  • 3210
收藏助手
不良信息举报
您举报文章:Java多线程实现方式
举报原因:
原因补充:

(最多只允许输入30个字)