十、多线程
Runnable、Thread、Callable、Future、FutureTask、Executor、ExecutorService、CompletionService、ThreadGroup
run() 执行线程运行的方法 ;Runnable:在执行并发编程之中提供一个公共的协议。![]()
Callable:与Runnable一样是为了提供公共协议的出现的,但是Callable执行的方法有返回值
call() 执行线程运行的方法;
ThreadGroup:线程组表示一个线程的集合。
super(threadPoolID + ""); 指定ThreadGroup的名称ID ;setDaemon(true) 设置线程为后台线程 ;Thread(ThreadGroup.this,id+"") 往线程组添加线程,并设置该线程ID ;
Thread:线程是程序中的执行线程。线程控制的核心类
cancel() 取消此任务Future:表示异步运算的结果。提供了检查计算是否完成的方法,等待计算完成,以及获取计算的结果。activeCount() 返回当前线程组中活动的线程数目 ;checkAccess() 判断当前运行线程是否有权限修改该线程 ;enumerate(Thread[] tarray) 将当前线程组及其子组中的每一个活动线程复制到指定的数组中interrupt() 中断线程join() 等待该线程终止setDaemon(boolean) true表示设置为后台线程 false为用户线程run() 执行线程运行的方法
get() 等待计算完成,然后获取其结果
isCancelled() 如果任务正常完成前将其取消,则返回true
isDone() 如果任务完成,则返回true
FutureTask:Future的子类,对Future类进行了扩充,添加了对进行时任务①状态②结果的控制
done() 将此任务设置为完成状态runAndReset() 运行但不计较结果,运行完毕会将Future重置为初始化状态set(V v) 将Future结果设置为v ;
Executor:是Callable、Future、ExecutorService的父类,提供了将任务提交与任务运行机制分离开来的方法。
execute(Runnable) 未来某个时间执行的指令。
ExecutorService:Executor的子类,对Executor进行了扩充,扩充了对执行器的管理方法。
invokeAll(Collection<? extends Callable<T>> tasks) 执行给定任务,完成所有任务返回结果集shutDown() 执行之前的任务,不接受新任务shutDownNow() 停止所有的任务,并返回正在等待的任务列表submit(Callable<T> task) 提交任务执行,并返回Future结果
CompletionService:产生新的异步任务,与已完成的任务结果分离开来。
poll() 获取任务结果,并删除该任务take() 获取并移除下一个已完成任务的Future,如果不存在则等待submit(Runnable task) 提交要执行的值返回任务,并返回表示挂起的任务结果的 Future(该Future是空白的)。在完成时,可能会提取或轮询次任务。
实例:
ThreadGroup、Runnable、Thread 自己实现线程池:
package net.itaem.test; import java.util.LinkedList; /** * * 手动线程池 * @author sen * @version 1.0,2014年8月26日 */ @SuppressWarnings("rawtypes") public class ThreadPool extends ThreadGroup{ private boolean isClosed = false; //线程池是否关闭 private LinkedList workQueue; //工作队列 private static int threadPoolID = 1; //线程池的id public ThreadPool(int poolSize) { //poolSize 表示线程池中的工作线程的数量 super(threadPoolID + ""); //指定ThreadGroup的名称 setDaemon(true); //继承到的方法,设置是否守护线程池 如果为 true,则表示此线程组是一个后台程序线程组;否则,表示此线程组是一个普通线程组。 workQueue = new LinkedList(); //创建工作队列 for(int i = 0; i < poolSize; i++) { new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程 } } /** 向工作队列中加入一个新任务,由工作线程去执行该任务*/ @SuppressWarnings("unchecked") public synchronized void execute(Runnable task) { if(isClosed) { throw new IllegalStateException(); } if(task != null) { workQueue.add(task);//向队列中加入一个任务 notify(); //唤醒一个正在getTask()方法中待任务的工作线程 } } /** 从工作队列中取出一个任务,工作线程会调用此方法*/ private synchronized Runnable getTask(int threadid) throws InterruptedException { while(workQueue.size() == 0) { if(isClosed) return null; System.out.println("工作线程"+threadid+"等待任务..."); wait(); //如果工作队列中没有任务,就等待任务 } System.out.println("工作线程"+threadid+"开始执行任务..."); return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除 } /** 关闭线程池 */ public synchronized void closePool() { if(! isClosed) { waitFinish(); //等待工作线程执行完毕 isClosed = true; workQueue.clear(); //清空工作队列 interrupt(); //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类 } } /** 等待工作线程把所有任务执行完毕*/ public void waitFinish() { synchronized (this) { isClosed = true; notifyAll(); //唤醒所有还在getTask()方法中等待任务的工作线程 } Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。 int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类,根据活动线程的估计值获得线程组中当前所有活动的工作线程 for(int i =0; i < count; i++) { //等待所有工作线程结束 try { threads[i].join(); //等待工作线程结束 }catch(InterruptedException ex) { ex.printStackTrace(); } } } /** * 内部类,工作线程,负责从工作队列中取出任务,并执行 * @author sunnylocus */ private class WorkThread extends Thread { private int id; public WorkThread(int id) { //父类构造方法,将线程加入到当前ThreadPool线程组中 super(ThreadPool.this,id+""); this.id =id; } public void run() { while(!isInterrupted()) { //isInterrupted()方法继承自Thread类,判断线程是否被中断 Runnable task = null; try { task = getTask(id); //取出任务 }catch(InterruptedException ex) { ex.printStackTrace(); } //如果getTask()返回null或者线程执行getTask()时被中断,则结束此线程 if(task == null) return; task.run(); //运行任务 }// end while }// end run }// end workThread }
Executor、Runnable、Thread、Callable、Future、FutureTask、ExecutorService、CompletionService:
package net.itaem.test; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class ExecutorTest { private int count = 0 ; public static void main(String[] args) { //Executor的使用 Executor executor = Executors.newFixedThreadPool(10); Runnable task = new Runnable() { @Override public void run() { System.out.println("task over"); } }; /* executor.execute(task); executor = Executors.newScheduledThreadPool(10); ScheduledExecutorService scheduler = (ScheduledExecutorService) executor; scheduler.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS); */ //ExecutorService的使用 /*ExecutorService executorService = (ExecutorService) executor; while (!executorService.isShutdown()) { try { executorService.execute(task); } catch (RejectedExecutionException ignored) { } } executorService.shutdown(); */ //Callable与Future的使用 /*Callable<Integer> func = new Callable<Integer>(){ //像Runnable,但是可返回结果 public Integer call() throws Exception { System.out.println("inside callable"); Thread.sleep(1000); return new Integer(8); } }; FutureTask<Integer> futureTask = new FutureTask<Integer>(func); //控制Callable返回的Future Thread newThread = new Thread(futureTask); newThread.start(); try { System.out.println("blocking here"); Integer result = futureTask.get(); System.out.println(result); } catch (InterruptedException ignored) { } catch (ExecutionException ignored) { } */ /*ExecutorService executorService = (ExecutorService) executor ; Future f = executorService.submit(func) ; System.out.println((Integer)f.get());*/ int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 , 12}; Caculators calc = new Caculators(); Long sum = calc.sum(numbers); System.out.println(sum); calc.close(); } }