Java多线程实现的方式有四种

1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程

前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

方式1：继承Thread类的线程实现方式如下：

  1. public class ThreadDemo01 extends Thread{
  2.    public ThreadDemo01(){
  3.        //编写子类的构造方法，可缺省
  4.    }
  5.    public void run(){
  6.        //编写自己的线程代码
  7.        System.out.println(Thread.currentThread().getName());
  8.    }
  9.    public static void main(String[] args){
  10.        ThreadDemo01 threadDemo01 = new ThreadDemo01();
  11.        threadDemo01.setName("我是自定义的线程1");
  12.        threadDemo01.start();      
  13.        System.out.println(Thread.currentThread().toString());  
  14.    }
  15. }

程序结果：
Thread[main,5,main]
我是自定义的线程1

方式2：通过实现Runnable接口，实现run方法

接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数，通过调用start()方法启动线程

  1. public class ThreadDemo02 {
  2.    public static void main(String[] args){
  3.        System.out.println(Thread.currentThread().getName());
  4.        Thread t1 = new Thread(new MyThread());
  5.        t1.start();
  6.    }
  7. }
  8. class MyThread implements Runnable{
  9.    @Override
  10.    public void run() {
  11.        // TODO Auto-generated method stub
  12.        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
  13.    }  
  14. }

程序运行结果：
main
Thread-0–>我是通过实现接口的线程实现方式！

方式3：通过Callable和FutureTask创建线程

  • a:创建Callable接口的实现类 ，并实现Call方法
  • b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值
  • c:使用FutureTask对象作为Thread对象的target创建并启动线程
  • d:调用FutureTask对象的get()来获取子线程执行结束的返回值
  1. public class ThreadDemo03 {
  2.    /**
  3.     * @param args
  4.     */
  5.    public static void main(String[] args) {
  6.        // TODO Auto-generated method stub
  7.        Callable<Object> oneCallable = new Tickets<Object>();
  8.        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
  9.        Thread t = new Thread(oneTask);
  10.        System.out.println(Thread.currentThread().getName());
  11.        t.start();
  12.    }
  13. }
  14. class Tickets<Object> implements Callable<Object>{
  15.    //重写call方法
  16.    @Override
  17.    public Object call() throws Exception {
  18.        // TODO Auto-generated method stub
  19.        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
  20.        return null;
  21.    }  
  22. }

程序运行结果：
main
Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

方式4：通过线程池创建线程

  1. public class ThreadDemo05{
  2.    private static int POOL_NUM = 10;     //线程池数量
  3.    /**
  4.     * @param args
  5.     * @throws InterruptedException
  6.     */
  7.    public static void main(String[] args) throws InterruptedException {
  8.        // TODO Auto-generated method stub
  9.        ExecutorService executorService = Executors.newFixedThreadPool(5);  
  10.        for(int i = 0; i<POOL_NUM; i++)  
  11.        {  
  12.            RunnableThread thread = new RunnableThread();
  13.            //Thread.sleep(1000);
  14.            executorService.execute(thread);  
  15.        }
  16.        //关闭线程池
  17.        executorService.shutdown();
  18.    }  
  19. }
  20. class RunnableThread implements Runnable  
  21. {    
  22.    @Override
  23.    public void run()  
  24.    {  
  25.        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  
  26.    }  
  27. }

程序运行结果：
通过线程池方式创建的线程：pool-1-thread-3
通过线程池方式创建的线程：pool-1-thread-4
通过线程池方式创建的线程：pool-1-thread-1
通过线程池方式创建的线程：pool-1-thread-5
通过线程池方式创建的线程：pool-1-thread-2
通过线程池方式创建的线程：pool-1-thread-5
通过线程池方式创建的线程：pool-1-thread-1
通过线程池方式创建的线程：pool-1-thread-4
通过线程池方式创建的线程：pool-1-thread-3
通过线程池方式创建的线程：pool-1-thread-2

ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，还有Future接口也是属于这个框架，有了这种特征得到返回值就很方便了。
通过分析可以知道，他同样也是实现了Callable接口，实现了Call方法，所以有返回值。这也就是正好符合了前面所说的两种分类

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

再介绍Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

  • public static ExecutorService newFixedThreadPool(int nThreads)

创建固定数目线程的线程池。

  • public static ExecutorService newCachedThreadPool()

创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的， 则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

  • public static ExecutorService newSingleThreadExecutor()

创建一个单线程化的Executor。

  • public static ScheduledExecutorService newScheduledThreadPool(int

corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

  • ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成

————————————————

版权声明：本文为CSDN博主「504的小菜鸟」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/u011480603/article/details/75332435/