Java多线程之线程返回值

短命女 2022-04-12 06:55 381阅读 0赞

对于Java多线程的理解，我以前仅仅局限于实现Runnable接口或者继承Thread类，然后重写run()方法，最后start()调用就算完事，但是一旦涉及死锁以及对共享资源的访问和随时监控线程的状态和执行顺序等等就不行了，所以现在开始看Thinking in java的并发这一节，从头学多线程，  
下面发一个关于线程中的任务返回，和创建线程池的代码

package com.bird.thinking;  
    
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    
    /** 
     * @use 使用Executor显示的创建Thread对象 
     * @author Bird 
     * 
     */  
    
    
    class LiftOff implements Runnable{//创建一个类实现Runable接口  
        protected int countDown = 10;  
        private static int taskCount = 0;  
        private final int id = taskCount++;  
        public LiftOff(){}  
        public LiftOff(int countDown){  
            this.countDown = countDown;  
        }  
    
        public String status(){  
            return "#"+id+"("+(countDown > 0 ? countDown : "Liftoff !" + ")");  
        }  
    
        public void run(){  
            while(countDown-- > 0){  
                System.out.println(status());  
                Thread.yield();  
            }  
        }  
    }  
    
    public class CachedThreadPool {  
        public static void main(String[] args){  
            ExecutorService exec = Executors.newCachedThreadPool();//创建线程池  
            for(int i = 0; i < 5; i++){  
                exec.execute(new LiftOff());//进行工作  
            }  
            exec.shutdown();  
        }  
    }

Executor为执行器，将为你管理Thread对象，从而简化了并发编  
  
程。Executor在客户端和任务执行之间提供了一个间接层，与客户  
  
端直接执行任务不同，这个中介对象将执行任务。Executor允许你  
  
管理异步任务的执行，而无需显示的管理线程的生命周期。  
  
Executor是Java SE6/7中启动任务的优选方法。  
下面的代码就能够随时监控各个线程的状态了

ackage com.bird.thinking;  
    
    import java.util.ArrayList;  
    import java.util.concurrent.Callable;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.Future;  
    
    /** 
     * @use 创建从任务中返回值的多线程，可以判断他的状态 
     * @author Bird 
     * 
     */  
    
    class TaskWithResult implements Callable<String>{//实现这个接口，调用的是call()方法  
        private int id;  
        public TaskWithResult(int id){  
            this.id  = id;  
        }  
    
        public String call(){  
            return "result of TaskWithResult" + id;  
        }  
    }  
    
    public class CallableDemo {  
        public static void main(String[] args){  
            ExecutorService exec = Executors.newCachedThreadPool();  
            ArrayList<Future<String>>  results = new ArrayList<Future<String>>();  
            for(int i = 0; i < 10; i++){  
                results.add(exec.submit(new TaskWithResult(i)));  
            }  
            for(Future<String> fs : results){  
                try{  
                    System.out.println(fs.get());//可以调用很多方法，包括是否工作等等  
                }catch(Exception e){  
                    e.printStackTrace();  
                }finally{  
                    exec.shutdown();  
                }  
            }  
        }  
    }

\[size=medium\]\[size=xx-small\]Submit方法会产生Future对象，他用Callable返回结果的特定类型  
  
进行了参数化。你可以用isDemo()方法来查询Future()是够已经完  
  
成。当任务完成的时候，他具有一个结果，你可以调用get()方法  
  
获得这个结果。  
  
Java 6/7最佳的休眠方法为TimeUnit.MILLISECONDS.sleep(100);\[/size\]\[/size\]  
  
  
最好不要用 Thread.sleep(100);