十、多线程_多线程编程live-CSDN博客

本文链接：https://blog.csdn.net/u010981492/article/details/41480093

十、多线程

Runnable、Thread、Callable、Future、FutureTask、Executor、ExecutorService、CompletionService、ThreadGroup

Runnable:在执行并发编程之中提供一个公共的协议。

run() 执行线程运行的方法 ;

Callable:与Runnable一样是为了提供公共协议的出现的，但是Callable执行的方法有返回值

call() 执行线程运行的方法；

ThreadGroup:线程组表示一个线程的集合。

super(threadPoolID + ""); 指定ThreadGroup的名称ID ;

setDaemon(true) 设置线程为后台线程 ;

Thread(ThreadGroup.this，id+"") 往线程组添加线程，并设置该线程ID ;

Thread:线程是程序中的执行线程。线程控制的核心类

activeCount() 返回当前线程组中活动的线程数目；

checkAccess() 判断当前运行线程是否有权限修改该线程；

enumerate(Thread[] tarray) 将当前线程组及其子组中的每一个活动线程复制到指定的数组中

interrupt() 中断线程

join() 等待该线程终止

setDaemon(boolean) true表示设置为后台线程 false为用户线程

run() 执行线程运行的方法

Future:表示异步运算的结果。提供了检查计算是否完成的方法，等待计算完成，以及获取计算的结果。

cancel() 取消此任务

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();  
	}
	
}