Java线程池

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author bg
*/
public class ThreadpoolTest
{

    public static void main(String[] args)
    {
//        ExecutorService pool = Executors.newFixedThreadPool(20);
//        ExecutorService pool = Executors.newCachedThreadPool();
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++)
        {
            final int task = i;
            pool.execute(new Runnable()
            {
                @Override
                public void run()
                {
                    for (int j = 0; j < 10; j++)
                    {
                        try
                        {
                            Thread.sleep(200);
                        } catch (InterruptedException ex)
                        {
                            Logger.getLogger(ThreadpoolTest.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        System.out.println(Thread.currentThread().getName() + ":" + task);
                    }
                }
            });
        }
        pool.shutdown();
       
        Executors.newScheduledThreadPool(2).scheduleAtFixedRate(new Runnable() {

            @Override
            public void run()
            {
                System.out.println("#############################");
            }
        }, 2, 2, TimeUnit.SECONDS);
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
*
* @author bg
*/
public class CallableAndFuture
{
   
    public static void main(String[] args) throws Exception
    {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<String> future = pool.submit(new Callable<String>()
        {
            @Override
            public String call() throws Exception
            {
                Thread.sleep(5000);
                return "hello";
            }
        });
       
        System.out.println("等待结果");
       
        System.out.println(future.get());
    }
}

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package threadpool;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
*
* @author bg
*/
public class CallableAndFuture
{

    public static void main(String[] args) throws Exception
    {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        Future<String> future = pool.submit(new Callable<String>()
        {
            @Override
            public String call() throws Exception
            {
                Thread.sleep(5000);
                return "hello";
            }
        });

        System.out.println("等待结果");

        System.out.println(future.get());

        CompletionService completionService = new ExecutorCompletionService(pool);
        for (int i = 1; i <= 10; i++)
        {
            final int seq = i;
            completionService.submit(new Callable()
            {
                @Override
                public Object call() throws Exception
                {
                    Thread.sleep(new Random().nextInt(3000));
                    return seq;
                }
            });
        }

        for (int i = 1; i <= 10; i++)
        {
            System.out.println(completionService.take().get());
        }
    }
}