可以取得返回值的线程

Java多线程实践
最新推荐文章于 2022-08-10 11:54:36 发布
转载 最新推荐文章于 2022-08-10 11:54:36 发布 · 949 阅读 · 2

编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable.

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以
(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

1、通过实现Runnable接口来创建Thread线程：

  步骤1：创建实现Runnable接口的类：

         
class SomeRunnable implements Runnable
{
    public void run()
    {
      //do something here
    }
}

步骤2：创建一个类对象：

       Runnable oneRunnable = new SomeRunnable();

步骤3：由Runnable创建一个Thread对象：

       Thread oneThread = new Thread(oneRunnable);

步骤4：启动线程：

        oneThread.start();

至此，一个线程就创建完成了。

注释：线程的执行流程很简单，当执行代码oneThread.start();时，就会执行oneRunnable对象中的void run();方法，

该方法执行完成后，线程就消亡了。

2、与方法1类似，通过实现Callable接口来创建Thread线程：其中，Callable接口（也只有一个方法）定义如下：

public interface Callable<V>   
{   
    V call() throws Exception;   
} 
步骤1：创建实现Callable接口的类SomeCallable<Integer>（略）；

步骤2：创建一个类对象：

      Callable<Integer> oneCallable = new SomeCallable<Integer>();

步骤3：由Callable<Integer>创建一个FutureTask<Integer>对象：

      FutureTask<Integer> oneTask = new FutureTask<Integer>(oneCallable);

      注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。
步骤4：由FutureTask<Integer>创建一个Thread对象：

       Thread oneThread = new Thread(oneTask);

步骤5：启动线程：

       oneThread.start();

至此，一个线程就创建完成了。

3、通过继承Thread类来创建一个线程：

步骤1：定义一个继承Thread类的子类：

       

class SomeThead extends Thraad
{
    public void run()
    {
     //do something here
    }
}

步骤2：构造子类的一个对象：

      SomeThread oneThread = new SomeThread();

步骤3：启动线程：

      oneThread.start();

至此，一个线程就创建完成了。

       注释：这种创建线程的方法不够好，主要是因为其涉及运行机制问题，影响程序性能。

4、通过线程池来创建线程：

步骤1：创建线程池：

      ExecutorService pool = Executors.newCachedThreadPool();

步骤2：通过Runnable对象或Callable对象将任务提交给ExecutorService对象：

      Future<Integer> submit(Callable<Integer> task);

      注释：Future是一个接口，它的定义如下：

               
public interface Future<T>
{
    V get() throws ...;
    V get(long timeout, TimeUnit unit) throws ...;
    void cancle(boolean mayInterrupt);
    boolean isCancelled();
    boolean isDone();
}

      至此，一个线程就创建完成了。

      注释：线程池需调用shutdown();方法来关闭线程。

5、通过事件分配线程直接使用程序中的原有线程：

使用方法：
直接调用EventQueue类的静态方法invokeLater()：

      EventQueue.invokeLater(oneRunnable);

      注释：调用EventQueue.invokeLater(oneRunnable);会直接执行oneRunnable对象中的run()方法




Runnbale封装一个异步运行的任务，可以把它想象成一个没有任何参数和返回值的异步方法。Callable和Runnable相似，但是它有返回值。Callable接口是参数化的类型，只有一个方法call

public interface Callable<V> {

    V call() throws Exception;

}

类型参数就是返回值的类型，例如：Callable<String>表示最终返回一个String的异步操作（计算）

Runnbale封装一个异步运行的任务，可以把它想象成一个没有任何参数和返回值的异步方法。Callable和Runnable相似，但是它有返回值。Callable接口是参数化的类型，只有一个方法call（）

public interface Callable<V> {

    V call() throws Exception;

}

类型参数就是返回值的类型，例如：Callable<String>表示最终返回一个String的异步操作（计算）

  1. //求素数 
  2. class PrimeCallable implements Callable<int[]> { 
  3.     private int max; 
  4.      
  5.     public PrimeCallable(int max) { 
  6.         this.max = max; 
  7.     } 
  8.      
  9.     @Override 
  10.     public int[] call() throws Exception { 
  11.         List<Integer> result = new ArrayList<Integer>(); 
  12.         for(int i = 2; i <= max; i++) { 
  13.             System.out.println("System is checking data " + i); 
  14.             if(isPrime(i)) { 
  15.                 result.add(i); 
  16.             } 
  17.         } 
  18.          
  19.         Integer[] iters = result.toArray(new Integer[]{}); 
  20.         int[] array = new int[iters.length]; 
  21.         int i = 0; 
  22.         for(Integer iter : iters) { 
  23.             array[i++] = iter; 
  24.         } 
  25.         return array; 
  26.     } 
  27.      
  28.     private boolean isPrime(int data) { 
  29.         try { 
  30.             Thread.sleep(5); 
  31.         } catch (InterruptedException e) { 
  32.             e.printStackTrace(); 
  33.         } 
  34.         for(int i = 2; i < ((int)Math.sqrt(data)+1); i++) { 
  35.             if(data % i == 0)  
  36.                 return false; 
  37.         } 
  38.         return true; 
  39.     } 
  40. } 

  1. Callable<int[]> primeCallable = new PrimeCallable(1000); 
  2.         FutureTask<int[]> ftask = new FutureTask<int[]>(primeCallable); 
  3.          
  4.         Thread t = new Thread(ftask); 
  5.         t.start(); 
  6.          
  7.         int[] result = null; 
  8.         System.out.println("Waiting for result....."); 
  9.         try { 
  10.             result = ftask.get(); 
  11.         } catch (InterruptedException e) { 
  12.             e.printStackTrace(); 
  13.         } catch (ExecutionException e) { 
  14.             e.printStackTrace(); 
  15.         } 
  16.          
  17.         for(int i = 0; result != null && i < result.length; i++) { 
  18.             if(i != 0 && i % 10 == 0) { 
  19.                 System.out.println(); 
  20.             } 
  21.             System.out.print(String.format("%1$-5s", result[i])); 
  22.         } 

  1. 执行结果： 
  2. Waiting for result..... 
  3. System is checking data 2 
  4. System is checking data 3 
  5. System is checking data 4 
  6. System is checking data 5 
  7. System is checking data 6 
  8. System is checking data 7 
  9. .................................. 
  10. System is checking data 999 
  11. System is checking data 1000 
  12. 2    3    5    7    11   13   17   19   23   29    
  13. 31   37   41   43   47   53   59   61   67   71    
  14. 73   79   83   89   97   101  103  107  109  113   
  15. 127  131  137  139  149  151  157  163  167  173   
  16. 179  181  191  193  197  199  211  223  227  229   
  17. 233  239  241  251  257  263  269  271  277  281   
  18. 283  293  307  311  313  317  331  337  347  349   
  19. 353  359  367  373  379  383  389  397  401  409   
  20. 419  421  431  433  439  443  449  457  461  463   
  21. 467  479  487  491  499  503  509  521  523  541   
  22. 547  557  563  569  571  577  587  593  599  601   
  23. 607  613  617  619  631  641  643  647  653  659   
  24. 661  673  677  683  691  701  709  719  727  733   
  25. 739  743  751  757  761  769  773  787  797  809   
  26. 811  821  823  827  829  839  853  857  859  863   
  27. 877  881  883  887  907  911  919  929  937  941   
  28. 947  953  967  971  977  983  991  997   

 


多线程编程(6)之三种实现有返回值的多线程
jokeMqc的博客
02-25 3382
可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子 JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有
有返回值的线程
07-27
NULL 博文链接：https://ericlntm.iteye.com/blog/742942
Java多线程的实现方式比较(两种方式比较)
09-03
Java多线程实现方式有两种，第一种是继承Thread类，第二种是实现Runnable接口，两种有很多差异，下面跟着本文一起学习吧
Callable,Runnable比较及用法
热门推荐
xtwolf008－－关注分布式存储，关注大数据，云计算PAAS
07-03 3万+
编写多线程程序是为了实现多任务的并发执行，从而能够更好地与用户交互。一般有三种方法，Thread,Runnable,Callable. Runnable和Callable的区别是， (1)Callable规定的方法是call(),Runnable规定的方法是run(). (2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得 (3)call方法可以抛出异常，ru
Java线程：新特征-有返回值的线程
玩一玩Java
11-25 478
 在Java5之前，线程是没有返回值的，常常为了“有”返回值，破费周折，而且代码很不好写。或者干脆绕过这道坎，走别的路了。   现在Java终于有可返回值的任务（也可以叫做线程）了。   可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。   执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可...
说说多线程的实现方式以及多线程实现方式之间的区别
紫乾2014的博客
11-16 1243
1、创建多线程方式分为普通创建和线程池创建两大类，线程池创建相对于普通创建使用效率更高，因为普通创建线程只有处理到对应部分逻辑的时候才会被用到，其它时间是会被闲置的，而线程池则不同，线程对象任务执行完成后线程是会被收回到线程池的可供其它需要用到多线程的地方使用从而减少闲置提高使用效率。 2、普通创建可以分为继承Thread类重写run方法和实现Runnable接口重写run方法。两者的区别在于继承Thread类是将创建线程对象和执行任务绑定在一起了，而实现Runnable接口重写run方法则是将创建线程对
多线程的实现方式,区别,停止线程的方式有几种
weixin_43177615的博客
10-11 1948
多线程的实现方式有如下三种 1）继承Thread类创建线程 重写run方法 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 重写call方法 通过继承Thread类来创建并启动多线程的一般步骤如下 1. 定义Thread类的子类,并重写该类的run()方法,该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。 2 通过实现Runnable接口...
说说Runnable与Callable
dgqvhtlwq472235338的博客
04-13 196
原文：http://www.cnblogs.com/frinder6/p/5507082.html 相同点： 两者都是接口；（废话） 两者都可用来编写多线程程序； 两者都需要调用Thread.start()启动线程； 不同点： 两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果； Call...
* 有返回值的线程
weixin_39904033的博客
09-26 300
import java.util.concurrent.*;   import java.util.Date;   import java.util.List;   import java.util.ArrayList;      /**  * 有返回值的线程  */   @SuppressWarnings("unchecked")   public class Test {   public s...
带返回值的线程（callable）
qq_38807606的博客
07-11 770
1. FutureTask 类 的 run() 方法 来自 Runnable 的run () 方法，所以 走 run () 方法就会执行 call() 方法 原理： 源码如下： public interface RunnableFuture<V> extends Runnable, Future<V> { /** * Sets this Future to the result of its computation * unl...
多线程的实现方式及其区别
weixin_30315723的博客
05-09 387
实现多线程有两种方式：(自JDK1.5之后有三种，最后一种并不常用) 　　1.继承Thread类 　　2.实现Runnable接口（Callable接口） 一个类如果实现了Runnable接口或者继承了Thread类，那么它就是一个多线程类，如果是要实现多线程，还需要重写run()方法，所以run() 方法是多线程的入口。 但是在启动多线程的时候，不是从run()方法开始的...
有返回值的多线程：Callable与Future、FutureTask
qq_33617861的博客
08-17 421
有返回值的多线程：Callable与Future、FutureTask Callable Callable是一个泛型接口，只实现了一个call()方法，这个跟Runnable类似，但是call()方法返回了一个传入的泛型结果，并且该方法是会抛出异常的 public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @r
带有返回值的多线程
aiyongbo123456的博客
02-16 2016
通过ExecuteService,Callable,Future实现带有返回值的多线程： 1、通过实现Callable接口创建线程类 package com.example.demo.morethread; import java.util.concurrent.*; /** *使用带有返回值的线程 */ public class CallableDemo implements Ca...
多线程实现的4种方法及比较
qq_43290655的博客
08-10 702
多线程实现的4种方法及比较
linux 线程无法取得
最新发布
01-20
使用`pthread_create()`函数创建线程时应始终检查其返回值[^1]。 ```c #include #include #include void* thread_function(void *arg){ printf("Thread is running\n"); return NULL; } int main(){ ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值