Callable ，Runnable 和 Thread

最新推荐文章于 2025-02-17 15:22:22 发布

飞奔的裸羊羊

最新推荐文章于 2025-02-17 15:22:22 发布

阅读量606

点赞数

分类专栏： java 文章标签：线程多线程

本文链接：https://blog.youkuaiyun.com/walle167/article/details/50518441

版权

java 专栏收录该内容

50 篇文章

订阅专栏

本文深入探讨了多线程编程的核心概念，包括Runnable、Thread和Callable的使用方法，并通过一个简单的火车售票程序实例展示了如何实现多线程。重点介绍了Callable的特性，即能够返回结果，以及Future.get()方法在获取返回值时的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一直在用多线程，但是一直没有好好整理一下。
目前来说，关于多线程就只有这三个

runnable
thread
callable

1. Runnable

Runable 和 thread 其实差不多。但是一般对于多线程的实现都是用Runable，然后使用 new Thread(Runable).start().这样的方式来使用。简单的说，就是线程中的逻辑用 runnable 来实现。然后多线程的执行方法，用thread来实现。
这样的好处就是，可以实现资源共享，同时又是多线程的方式。具体代码如下

package com.luoy.Thread;

import java.util.List;


public class TreadRunable implements Runnable{

   private List<String> list;

   public TreadRunable(List<String> list){
      this.list = list;
   }

   private synchronized  String getAccount(){
      String a = list.get(0);
      list.remove(a);
      return a ;
   }

   @Override
   public void run(){
      // TODO Auto-generated method stub
         while(list.size() > 0){
            String account = getAccount();
            System.out.println("线程："+Thread.currentThread().getName()+",手机号码是:"+account);
            try{
               Thread.sleep(100);
            }catch(InterruptedException e){
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
      }

   }

}

执行多线程

 public static void main(String[] args){
      RunableM();
   }


   private static void RunableM(){
      TreadRunable t = new TreadRunable(creatList());
      new Thread(t,"1").start();
      new Thread(t,"2").start();
      new Thread(t,"3").start();
   }
 private  static List<String> creatList(){
      List<String> list =  new ArrayList<String>();
      //List<String> list =  new CopyOnWriteArrayList<String>();
       list.add("111");
       list.add("222");
       list.add("333");
       list.add("444");
       list.add("555");
       list.add("666");
       list.add("777");
       list.add("888");
       list.add("999");
       list.add("000");
       return list;
   }

上面就是一个简单的火车售票程序。

2.thread

看上面 Runnable就知道了。不具体多说。

3.Callable

这个多线程方式，其实用的很少。
具体来说，它比其他的好处就是，能够得到返回值。
直接看代码

package com.luoy.Thread;

import java.util.List;
import java.util.concurrent.Callable;

public class TreadCallAble
      implements
         Callable<String>{

   private List<String> list;

   private String name;

   public TreadCallAble(List<String> list,String name){
      this.list = list;
      this.name = name;
   }

   private synchronized String getAccount(){
      String a = list.get(0);
      list.remove(a);
      return a;
   }



   @Override
   public String call() throws Exception{
      String ret = "";
      while(list.size() > 0){
         String account = getAccount();
         System.out.println("线程：" + name + ",手机号码是:" + account);
         ret += account+",";
         try{
            Thread.sleep(500);
         }catch(InterruptedException e){
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
      }
      return ret;
   }

}

执行方法

 public static void main(String[] args){
     callAble();
   }

 private static void callAble(){
      System.out.println("----程序开始运行----");
      Date date1 = new Date();
      int taskSize = 3;
      // 创建一个线程池
      ExecutorService pool = Executors.newFixedThreadPool(taskSize);
      // 创建多个有返回值的任务
      List<Future<String>> list = new ArrayList<Future<String>>();
      List<String> list1 = new ArrayList<String>();
      List<String>  dataList = creatList();
      Callable<String> c = new TreadCallAble(dataList,"");
      for (int i = 0; i < taskSize; i++) {
          // 执行任务并获取Future对象
         System.out.println("a:"+i);
          Future<String> f = pool.submit(c); 
          list.add(f);

      }
      // 关闭线程池
      pool.shutdown();
      Date date2 = new Date();
      System.out.println("----程序结束运行----，程序运行时间【"
              + (date2.getTime() - date1.getTime()) + "毫秒】");
      // 获取所有并发任务的运行结果
      System.out.println(list.size());
      for (Future<String> f : list) {
         System.out.println("111111111111");
         if(f.isDone()){
            System.out.println(f.isDone());
            try{
               System.out.println("结果："+f.get());
            }catch(InterruptedException e){
               // TODO Auto-generated catch block
               e.printStackTrace();
            }catch(ExecutionException e){
               // TODO Auto-generated catch block
               e.printStackTrace();
            }
         }else{
            while(!f.isDone()){
               if(f.isDone()){
                  System.out.println(f.isDone());
                  try{
                     System.out.println("结果："+f.get());
                  }catch(InterruptedException e){
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                  }catch(ExecutionException e){
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                  }
               }
            }
         }

      }


   }
}

callable 特别要注意的一定是返回值的获取 Future.get()。
这个方法，一旦执行这个方法，就会阻塞程序。知道这个线程执行完成，才会继续往下执行。
f.isCancelled()//判断是否取消
f.isDone()//判断是否执行完成
f.cancel(mayInterruptIfRunning) //取消执行