9、java线程

1、没有返回值的线程Runable

A、线程类

package com.my.thread;
import java.util.concurrent.BlockingQueue;
public class DemoRunable implements Runnable {
    private BlockingQueue<String> fileList;
    public DemoRunable(BlockingQueue<String>fileList) {
        this.fileList = fileList;
    }
    @Override
    public void run() {
        synchronized (fileList) {
            while(fileList.size()>0){
                String fileName;
                try {
                    fileName=fileList.take();
                    System.out.println(fileName);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

B、测试类

package com.my.thread;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class DemoRunableTest {
    public static void main(String[] args) {
        BlockingQueue<String> fileList=new ArrayBlockingQueue<String>(5);
        for(int i=0;i<5;i++){
            fileList.add(i+".txt");
        }
        DemoRunable dr=new DemoRunable(fileList);
        ExecutorService exe=Executors.newCachedThreadPool();
        exe.execute(dr);
        exe.shutdown();
    }
}

2、有返回值的线程Runable

A、线程类

package com.my.thread;
import java.util.concurrent.Callable;
//1.实现Callable接口，定义可返回结果的线程任务.泛型参数String表示的是该任务执行之后返回结果的类型。
public class CallableTestTest implements Callable<String> {
    private int id;
    public CallableTestTest(int id) {
        this.id = id;
    }
    @Override
    public String call() throws Exception {
        for(int i=0;i<10;i++){  
            System.out.println("this.str"+i);  
        }  
        return "result of TaskWithResult "+id;
    }
}

B、测试类

package com.my.thread;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableTest {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //2.将该任务交给线程执行者executor，让他来代理执行这些线程  该方法将返回一个Future接口的对象，它的泛型参数代表了call方法要返回的参数类型。
        ExecutorService exec=Executors.newCachedThreadPool();//工头线程池
        ArrayList<Future<String>> results=new ArrayList<Future<String>>(); //Future 相当于是用来存放Executor执行的结果的一种容器  
            results.add(exec.submit(new CallableTestTest(0)));
            results.add(exec.submit(new CallableTestTest(1)));
        /*3.Future类型
　　  　　 Future类型：按照名字判断该类型对象代表了线程执行完成后的结果，所以叫Future。那么在获取该类型存放的线程运行结果时，可能该线程并未运行完毕，

　　　所以称其为“将来的结果”。
    　　　首先，可以用isDone()方法来查询Future是否已经完成，任务完成后，可以调用get()方法来获取结果
    　 　　如果不加判断直接调用get方法，此时如果线程未完成，get将阻塞，直至结果准备就绪
         */
        for(Future<String> fs : results){
            if(fs.isDone()){
                System.out.println(fs.get());
            }else{
                System.out.println("Future result is not yet complete");
            }
        }
        exec.shutdown();
    }

}

3、有返回值的线程Runable应用

A、线程类

package com.my.thread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
public class Demo1Callable implements Callable<String> {
    private BlockingQueue<String> fileList;
    public Demo1Callable(BlockingQueue<String> fileList) {
        this.fileList= fileList;
    }
    @Override
    public String call() {
        String fileName=null;
        synchronized (fileList) {
            while(fileList.size()>0){
                try {
                    fileName=fileList.take();
                    return fileName;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        return fileName;
    }
}

B、测试类

package com.my.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo1CallableTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException {
        BlockingQueue<String> fileList=new ArrayBlockingQueue<String>(5);
        for(int i=0;i<5;i++){
            fileList.add(i+".txt");
        }
        Demo1Callable d1=new Demo1Callable(fileList);
        Demo1Callable d2=new Demo1Callable(fileList);
        ExecutorService pool=Executors.newCachedThreadPool();
        List<Future<String>> results=new ArrayList<Future<String>>();
        results.add(pool.submit(d1));
        results.add(pool.submit(d1));
        results.add(pool.submit(d2));
        for(Future<String> ft:results){
            System.out.println(ft.get());
        }
        pool.shutdown();
    }
}