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