1.  Executors
此类中提供的一些方法有:
1.1 public static ExecutorService newCachedThreadPool()
创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言,这些线程池通常可提高程序性能。
 
1.2 public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。
 
1.3 public static ExecutorService newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
 
这三个方法都可以配合接口ThreadFactory的实例一起使用。并且返回一个ExecutorService接口的实例。
2. 接口 ThreadFactory
根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了,从而允许应用程序使用特殊的线程子类、属性等等。
此接口最简单的实现就是:
class SimpleThreadFactory implements ThreadFactory {
   public Thread newThread(Runnable r) {
     return new Thread(r);
   }
 }
3. 接口ExecutorService
该接口提供了管理终止的方法。
4.测试用例:
  4.1固定大小线程:
代码 

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; /**
*
* @author hxm
*
*/
public class TestThread {
public static void main(String args[]){
//创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(4); //创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。
// ExecutorService pool = Executors.newSingleThreadExecutor();
//创建实现了runnable接口的对象
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();
}
}
class MyThread extends Thread{ @Override
public void run(){
System.out.println(Thread.currentThread().getName()+" is running...");
}
}

  4.2单任务线程:

package cn.itcast.heima2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; public class ThreadPoolTest { /**
* @param args
*/
public static void main(String[] args) {
//创建一个线程池
// ExecutorService threadPool = Executors.newFixedThreadPool(3);//创建3个线程
// ExecutorService threadPool = Executors.newCachedThreadPool();
ExecutorService threadPool = Executors.newSingleThreadExecutor();
for(int i=1;i<=10;i++){
final int task = i;
//往线程池里面添加任务
threadPool.execute(new Runnable(){
@Override
public void run() {
for(int j=1;j<=10;j++){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " is looping of " + j + " for task of " + task);
}
}
});
}
System.out.println("all of 10 tasks have committed! ");
//定时器
Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
System.out.println("bombing!"); }},
6,
2,
TimeUnit.SECONDS);
} }

  4.3 单任务延迟线程:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; /**
*
* @author hxm
*
*/
public class TestThread {
public static void main(String args[]){
//创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行
ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
//创建实现了runnable接口的对象
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
//使用延迟执行风格的方法
pool.schedule(t4, 10, TimeUnit.MILLISECONDS);
pool.schedule(t5, 10, TimeUnit.MILLISECONDS); //关闭线程池
pool.shutdown();
}
}
class MyThread extends Thread{ @Override
public void run(){
System.out.println(Thread.currentThread().getName()+" is running...");
}
}

  4.4 自定义线程池:

 import java.util.concurrent.ArrayBlockingQueue;
2 import java.util.concurrent.BlockingQueue;
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5 import java.util.concurrent.ScheduledExecutorService;
6 import java.util.concurrent.ThreadPoolExecutor;
7 import java.util.concurrent.TimeUnit;
8
9 /**
10 *
11 * @author hxm
12 *
13 */
14 public class TestThread {
15 public static void main(String args[]){
16 //创建等待队列
17 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
18 //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
19 ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);
20
21 //创建实现了runnable接口的对象
22 Thread t1 = new MyThread();
23 Thread t2 = new MyThread();
24 Thread t3 = new MyThread();
25 Thread t4 = new MyThread();
26 Thread t5 = new MyThread();
27 //将线程放入池中进行执行
28 pool.execute(t1);
29 pool.execute(t2);
30 pool.execute(t3);
31 pool.execute(t4);
32 pool.execute(t5);
33 //关闭线程池
34 pool.shutdown();
35 }
36 }
37 class MyThread extends Thread{
38
39 @Override
40 public void run(){
41 System.out.println(Thread.currentThread().getName()+" is running...");
42 try {
43 Thread.sleep(100L);
44 } catch (InterruptedException e) {
45 e.printStackTrace();
46 }
47 }
48 }

java多线程之 Executors线程池管理的更多相关文章

  1. Java多线程-新特性-线程池

    Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定可靠的多线程程序 ...

  2. Java多线程系列--“JUC线程池”06之 Callable和Future

    概要 本章介绍线程池中的Callable和Future.Callable 和 Future 简介示例和源码分析(基于JDK1.7.0_40) 转载请注明出处:http://www.cnblogs.co ...

  3. Java多线程系列--“JUC线程池”02之 线程池原理(一)

    概要 在上一章"Java多线程系列--“JUC线程池”01之 线程池架构"中,我们了解了线程池的架构.线程池的实现类是ThreadPoolExecutor类.本章,我们通过分析Th ...

  4. Java多线程系列--“JUC线程池”03之 线程池原理(二)

    概要 在前面一章"Java多线程系列--“JUC线程池”02之 线程池原理(一)"中介绍了线程池的数据结构,本章会通过分析线程池的源码,对线程池进行说明.内容包括:线程池示例参考代 ...

  5. 转:java多线程CountDownLatch及线程池ThreadPoolExecutor/ExecutorService使用示例

    java多线程CountDownLatch及线程池ThreadPoolExecutor/ExecutorService使用示例 1.CountDownLatch:一个同步工具类,它允许一个或多个线程一 ...

  6. Java多线程系列--“JUC线程池”04之 线程池原理(三)

    转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509960.html 本章介绍线程池的生命周期.在"Java多线程系列--“基础篇”01之 基 ...

  7. Java多线程系列--“JUC线程池”05之 线程池原理(四)

    概要 本章介绍线程池的拒绝策略.内容包括:拒绝策略介绍拒绝策略对比和示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3512947.html 拒绝策略 ...

  8. Java多线程学习之线程池源码详解

    0.使用线程池的必要性 在生产环境中,如果为每个任务分配一个线程,会造成许多问题: 线程生命周期的开销非常高.线程的创建和销毁都要付出代价.比如,线程的创建需要时间,延迟处理请求.如果请求的到达率非常 ...

  9. Java多线程之细说线程池

    前言 在认识线程池之前,我们需要使用线程就去创建一个线程,但是我们会发现有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因 ...

随机推荐

  1. python列表推导式详解

    推导式是Python中很强大的.很受欢迎的特性,具有语言简洁,简化代码,速度快等优点.推导式包括:1.列表推导式2.字典推导式3.集合推导式4.嵌套列表推导式注意: 字典和集合推导是最近才加入到Pyt ...

  2. AOJ - 0009 Prime Number (素数筛法) && AOJ - 0005 (求最大公约数和最小公倍数)

    http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=34870 求n内的素数个数. /* ********************* ...

  3. leetcode Database3(Nth Highest Salary<—>Consecutive Numbers<—>Department Highest Salary)

    一.Nth Highest Salary Write a SQL query to get the nth highest salary from the Employee table. +----+ ...

  4. STL头文件

    #include <iostream>标准输入输出cin cout等 #include <algorithm> 算法库 如sort find等 #include <vec ...

  5. java中final关键字

    一.final修饰方法 禁止任何继承类修改它的定义,保证在继承中使方法行为保持不闲并且不会被覆盖. final修饰的方法,同意编译器针对该方法的调用转为内嵌调用.(类似c++ 中的inline?) p ...

  6. Maven3路程(五)用Maven创建Hibernate项目

    本文将用Maven3.Hibernate3.6.Oracle10g整合,作为例子. 环境清单: 1.Maven3.0.5 2.Hibernate3.6.5 Final 3.JDK1.7.0.11 4. ...

  7. JavaScript 类的定义和引用 JavaScript高级培训 自定义对象

    在Java语言中,我们可以定义自己的类,并根据这些类创建对象来使用,在Javascript中,我们也可以定义自己的类,例如定义User类.Hashtable类等等.     一,概述 在Java语言中 ...

  8. java socket编程基础

    1. [代码]读操作Runable 1 package com.hrd.test.socket; import java.io.BufferedReader; import java.io.IOExc ...

  9. core--主线程

    windows的线程是windows可以分配给cpu的最小单元,对window应用程序的管理,最小的管理单位就是线程.那什么是线程?线程其实什么都不是,只是一个概念,没有实体,又看不见.这个概念的定义 ...

  10. HDU 1548 (最基础的BFS了) A strange lift

    这是一维的BFS,而且没有什么变形,应该是最基础的BFS了吧 题意: 有这样一个奇葩的电梯,你在第i层的时候你只能选择上或者下Ki层,也就是你只能从第i层到达i+Ki或者i-Ki层.当然电梯最低只能在 ...