JAVA线程池

      背景：系统启动一个线程的成本是比较高的，因为它涉及到与操作系统交互。在这种情况下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池

      原理：线程池在系统启动时就创建大量空闲线程，程序将一个Runnable对象传给线程池，线程池将会启动一条线程来执行该对象的run方法，当run方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run方法；此外，使用线程池可以有效控制系统中的并发线程的数量

     使用线程池来执行线程任务的步骤如下：

（1）调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池

（2）创建Runnable实现类 或 Callable实现类的实例，作为线程执行任务

（3）调用ExecutorService对象的submit方法来提交Runnable实例或Callable实例

（4）当不想提交任何任务时调用ExecutorService对象的shutdown方法来关闭线程池

 

　例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ThreadTest implements Runnable {
    public void run() {
        for (int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + "的i的值为：" + i);
        }
    }
}

public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(6);
        pool.submit(new ThreadTest());
        pool.submit(new ThreadTest());
        /*
        ThreadTest t1 = new ThreadTest();
        new Thread(t1).start();
        ThreadTest t2 = new ThreadTest();
        new Thread(t2).start();
        */
        pool.shutdown();
    }
}

 

执行结果为：

D:\聚划算\技术部\编程练习\Thread\ThradPoolTest>java ThreadPoolTest
pool-1-thread-1的i的值为：0
pool-1-thread-2的i的值为：0
pool-1-thread-1的i的值为：1
pool-1-thread-2的i的值为：1
pool-1-thread-1的i的值为：2
pool-1-thread-1的i的值为：3
pool-1-thread-1的i的值为：4
pool-1-thread-1的i的值为：5
pool-1-thread-1的i的值为：6
pool-1-thread-1的i的值为：7
pool-1-thread-1的i的值为：8 *****

 

 例子2：

package threadpool.ThreadFactory;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;


public class TestThreadFactory {
    private static String consumerThreadName="consumerThread";
    
    public static void main(String[] args) {
        ExecutorService executor=Executors.newSingleThreadExecutor(new ThreadFactory() {
            
            @Override
            public Thread newThread(Runnable r) {
                // TODO Auto-generated method stub
                return new Thread(r, consumerThreadName);
            }
        });
        executor.execute(new ConsumeRunnable());
    
    }
}

class ConsumeRunnable implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName() + "正在运行...");
        
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

这里线程工厂的好处就是可以自己定义线程的名字。

 

java.util.concurrent

Interface ExecutorService

• All Superinterfaces:

  Executor

  All Known Subinterfaces:

  ScheduledExecutorService

  All Known Implementing Classes:

  AbstractExecutorService, ForkJoinPool, ScheduledThreadPoolExecutor, ThreadPoolExecutor

  ---

  
  

  public interface ExecutorService
  extends Executor

  An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks.

  An ExecutorService can be shut down, which will cause it to reject new tasks. Two different methods are provided for shutting down an ExecutorService. The shutdown() method will allow previously submitted tasks to execute before terminating, while the shutdownNow() method prevents waiting tasks from starting and attempts to stop currently executing tasks. Upon termination, an executor has no tasks actively executing, no tasks awaiting execution, and no new tasks can be submitted. An unused ExecutorService should be shut down to allow reclamation of its resources.

  Method submit extends base method Executor.execute(java.lang.Runnable) by creating and returning a Future that can be used to cancel execution and/or wait for completion. Methods invokeAny andinvokeAll perform the most commonly useful forms of bulk execution, executing a collection of tasks and then waiting for at least one, or all, to complete. (Class ExecutorCompletionService can be used to write customized variants of these methods.)

  The Executors class provides factory methods for the executor services provided in this package.

 

 

java.util.concurrent

Class Executors

• java.lang.Object
• java.util.concurrent.Executors

• ---

  
  

  public class Executors
  extends Object

  Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package. This class supports the following kinds of methods:

  • Methods that create and return an ExecutorService set up with commonly useful configuration settings.
  • Methods that create and return a ScheduledExecutorService set up with commonly useful configuration settings.
  • Methods that create and return a "wrapped" ExecutorService, that disables reconfiguration by making implementation-specific methods inaccessible.
  • Methods that create and return a ThreadFactory that sets newly created threads to a known state.
  • Methods that create and return a Callable out of other closure-like forms, so they can be used in execution methods requiring Callable.

  Since:

  1.5

 

java.util.concurrent

Interface ThreadFactory

 

• ---

  
  

  public interface ThreadFactory

  An object that creates new threads on demand. Using thread factories removes hardwiring of calls to new Thread, enabling applications to use special thread subclasses, priorities, etc.

  The simplest implementation of this interface is just:

   class SimpleThreadFactory implements ThreadFactory {
     public Thread newThread(Runnable r) {
       return new Thread(r);
     }
   }
   

  The Executors.defaultThreadFactory() method provides a more useful simple implementation, that sets the created thread context to known values before returning it.

  Since:

  1.5