Java 多线程实现的三种方式

Java 多线程实现的三种方式

Java 多线程实现方式主要有三种:继承 Thread 类、实现 Runnable 接口、使用 ExecutorService、Callable、Future 实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。

1、继承 Thread 类实现多线程

继承 Thread 类的方法尽管被我列为一种多线程实现方式,但 Thread 本质上也是实现了 Runnable 接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过 Thread 类的 start () 实例方法。start () 方法是一个 native 方法,它将启动一个新线程,并执行 run () 方法。这种方式实现多线程很简单,通过自己的类直接 extend Thread,并复写 run () 方法,就可以启动新线程并执行自己定义的 run () 方法。例如:

1 public class MyThread extends Thread { 
2   public void run() { 
3    System.out.println("MyThread.run()"); 
4   } 
5 }

在合适的地方启动线程如下:

MyThread myThread1 = new MyThread(); 
MyThread myThread2 = new MyThread(); 
myThread1.start(); 
myThread2.start();

2、实现 Runnable 接口方式实现多线程

如果自己的类已经 extends 另一个类,就无法直接 extends Thread,此时,必须实现一个 Runnable 接口,如下:

public class MyThread extends OtherClass implements Runnable { 
  public void run() { 
   System.out.println("MyThread.run()"); 
  } 
}

为了启动 MyThread,需要首先实例化一个 Thread,并传入自己的 MyThread 实例:

MyThread myThread = new MyThread(); 
Thread thread = new Thread(myThread); 
thread.start();

事实上,当传入一个 Runnable target 参数给 Thread 后,Thread 的 run () 方法就会调用 target.run (),参考 JDK 源代码:

public void run() { 
  if (target != null) { 
   target.run(); 
  } 
}

3、使用 ExecutorService、Callable、Future 实现有返回结果的多线程

ExecutorService、Callable、Future 这个对象实际上都是属于 Executor 框架中的功能类。想要详细了解 Executor 框架的可以访问 http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在 JDK1.5 中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。

可返回值的任务必须实现 Callable 接口,类似的,无返回值的任务必须 Runnable 接口。执行 Callable 任务后,可以获取一个 Future 的对象,在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了,再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在 JDK1.5 下验证过没问题可以直接使用。代码如下:

import java.util.concurrent.*; 
import java.util.Date; 
import java.util.List; 
import java.util.ArrayList; 
  
/**
* 有返回值的线程
*/ 
@SuppressWarnings("unchecked") 
public class Test { 
public static void main(String[] args) throws ExecutionException, 
   InterruptedException { 
  System.out.println("----程序开始运行----"); 
  Date date1 = new Date(); 
  
  int taskSize = 5; 
  // 创建一个线程池 
  ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
  // 创建多个有返回值的任务 
  List<Future> list = new ArrayList<Future>(); 
  for (int i = 0; i < taskSize; i++) { 
   Callable c = new MyCallable(i + " "); 
   // 执行任务并获取Future对象 
   Future f = pool.submit(c); 
   // System.out.println(">>>" + f.get().toString()); 
   list.add(f); 
  } 
  // 关闭线程池 
  pool.shutdown(); 
  
  // 获取所有并发任务的运行结果 
  for (Future f : list) { 
   // 从Future对象上获取任务的返回值,并输出到控制台 
   System.out.println(">>>" + f.get().toString()); 
  } 
  
  Date date2 = new Date(); 
  System.out.println("----程序结束运行----,程序运行时间【" 
    + (date2.getTime() - date1.getTime()) + "毫秒】"); 
} 
} 
  
class MyCallable implements Callable<Object> { 
private String taskNum; 
  
MyCallable(String taskNum) { 
  this.taskNum = taskNum; 
} 
  
public Object call() throws Exception { 
  System.out.println(">>>" + taskNum + "任务启动"); 
  Date dateTmp1 = new Date(); 
  Thread.sleep(1000); 
  Date dateTmp2 = new Date(); 
  long time = dateTmp2.getTime() - dateTmp1.getTime(); 
  System.out.println(">>>" + taskNum + "任务终止"); 
  return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】"; 
} 
}

代码说明:

上述代码中 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 () 方法,会阻塞直到计算完成。

IDEA 保姆级安装教程:  http://note.youdao.com/s/Wq2GSETJ  

计算机专业常用毕业设计集合:  http://note.youdao.com/s/PIJHOqnk  

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
1. 继承Thread类 Java提供了Thread类,我们可以通过继承Thread类来实现多线程。具体步骤如下: (1)创建一个继承Thread类的子类,并重写run()方法。 (2)在子类中创建一个Thread类的实例对象,并调用start()方法启动线程。 示例代码如下: ``` public class MyThread extends Thread { @Override public void run() { // 线程执行的代码 } } // 创建线程并启动 MyThread myThread = new MyThread(); myThread.start(); ``` 2. 实现Runnable接口 Java中还可以通过实现Runnable接口来实现多线程。具体步骤如下: (1)创建一个实现Runnable接口的类,并实现run()方法。 (2)在类中创建一个Thread类的实例对象,将实现了Runnable接口的类的实例对象作为参数传入Thread的构造方法中。 (3)调用Thread实例对象的start()方法启动线程。 示例代码如下: ``` public class MyRunnable implements Runnable { @Override public void run() { // 线程执行的代码 } } // 创建线程并启动 MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start(); ``` 3. 实现Callable接口 Java中还可以通过实现Callable接口来实现多线程。与实现Runnable接口相比,实现Callable接口可以有返回值,并且可以抛出异常。具体步骤如下: (1)创建一个实现Callable接口的类,并实现call()方法。 (2)创建一个ExecutorService线程池对象,调用submit()方法提交Callable类的实例对象。 (3)调用Future类的get()方法获取线程执行结果。 示例代码如下: ``` public class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { // 线程执行的代码 return 1; } } // 创建线程池对象 ExecutorService executorService = Executors.newFixedThreadPool(1); // 提交Callable实例对象 MyCallable myCallable = new MyCallable(); Future<Integer> future = executorService.submit(myCallable); // 获取线程执行结果 int result = future.get(); ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员万万

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值