`
lzkyo
  • 浏览: 466190 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java 线程池

    博客分类：
  • Java
Java多线程threadXML工作 
阅读更多

1)threadpool.xml

Java代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <config>   
  3. 　　<threadPool>   
  4. 　　<minPools>10</minPools>　<!--线程池最小线程-->   
  5. 　　<maxPools>100</maxPools> <!--线程池最大线程-->   
  6. 　　<checkThreadPeriod>5</checkThreadPeriod>　<!--检查线程池中线程的周期5分钟-->   
  7. 　　</threadPool>   
  8. </config>  
<?xml version="1.0" encoding="UTF-8"?>
<config>
　　<threadPool>
　　<minPools>10</minPools>　<!--线程池最小线程-->
　　<maxPools>100</maxPools> <!--线程池最大线程-->
　　<checkThreadPeriod>5</checkThreadPeriod>　<!--检查线程池中线程的周期5分钟-->
　　</threadPool>
</config>



(2)解析XML文件

Java代码 复制代码
  1. import java.io.InputStream;   
  2. import java.util.Iterator;   
  3.   
  4. import org.dom4j.Document;   
  5. import org.dom4j.Element;   
  6. import org.dom4j.io.SAXReader;   
  7. import org.springframework.core.io.ClassPathResource;   
  8.   
  9. public class XMLReader {   
  10.   
  11.     private Document document;   
  12.   
  13.     private static final XMLReader instance =    
  14.         new XMLReader();    
  15.   
  16.         /**   
  17.         * 私有的默认构造子   
  18.         */    
  19.         private XMLReader() {   
  20.             loadXML();   
  21.         }    
  22.            
  23.         /**   
  24.         * 静态工厂方法   
  25.         */    
  26.         public static XMLReader getInstance()    
  27.         {   
  28.         return instance;    
  29.         }   
  30.   
  31.         private void loadXML(){   
  32.             InputStream is = null;   
  33.             SAXReader reader =null;   
  34.             try {   
  35.                 is = (new ClassPathResource("threadpool.xml")).getInputStream();   
  36.                 reader = new SAXReader();    
  37.                 document = reader.read(is);   
  38.                 is.close();   
  39.             } catch (Exception e) {   
  40.                 e.printStackTrace();   
  41.             }   
  42.         }   
  43.            
  44.         /**  
  45.          * 读取指定值  
  46.          * @param name  
  47.          * @return  
  48.          */  
  49.         public  String getThreadPoolPara(String name){   
  50.             String str = "";   
  51.             try {   
  52.                 Element root = document.getRootElement(); // 获得根元素   
  53.                 Iterator lv = root.elementIterator("threadPool");   
  54.                 Element el = null;   
  55.                 while (lv.hasNext()) {   
  56.                     el = (Element) lv.next();   
  57.                     str = el.element(name).getText();   
  58.                 }   
  59.             } catch (Exception e) {   
  60.                 System.out.println(e.toString());   
  61.             }   
  62.             return str;   
  63.         }   
  64.            
  65. }  
import java.io.InputStream;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.core.io.ClassPathResource;

public class XMLReader {

	private Document document;

	private static final XMLReader instance = 
		new XMLReader(); 

		/** 
		* 私有的默认构造子 
		*/ 
		private XMLReader() {
			loadXML();
		} 
		
		/** 
		* 静态工厂方法 
		*/ 
		public static XMLReader getInstance() 
		{
		return instance; 
		}

		private void loadXML(){
			InputStream is = null;
			SAXReader reader =null;
			try {
				is = (new ClassPathResource("threadpool.xml")).getInputStream();
				reader = new SAXReader(); 
				document = reader.read(is);
				is.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		/**
		 * 读取指定值
		 * @param name
		 * @return
		 */
		public  String getThreadPoolPara(String name){
			String str = "";
			try {
				Element root = document.getRootElement(); // 获得根元素
				Iterator lv = root.elementIterator("threadPool");
				Element el = null;
				while (lv.hasNext()) {
					el = (Element) lv.next();
					str = el.element(name).getText();
				}
			} catch (Exception e) {
				System.out.println(e.toString());
			}
			return str;
		}
		
}



(3)工作线程

Java代码 复制代码
  1. class WorkThread extends Thread {   
  2.     private boolean runningFlag;   
  3.   
  4.     private String argument;   
  5.   
  6.     public boolean isRunning() {   
  7.         return runningFlag;   
  8.     }   
  9.   
  10.     public synchronized void setRunning(boolean flag) {   
  11.         runningFlag = flag;   
  12.         if (flag)   
  13.             this.notify();   
  14.     }   
  15.   
  16.     public String getArgument() {   
  17.         return this.argument;   
  18.     }   
  19.   
  20.     public void setArgument(String string) {   
  21.         argument = string;   
  22.     }   
  23.   
  24.     public WorkThread(int threadNumber) {   
  25.         runningFlag = false;   
  26.         System.out.println("thread " + threadNumber + "started.");   
  27.     }   
  28.   
  29.     public synchronized void run() {   
  30.         try {   
  31.             while (true) {   
  32.                 if (!runningFlag) {   
  33.                     this.wait();   
  34.                 } else {   
  35.                     System.out.println("processing " + getArgument()   
  36.                             + "... done.");   
  37.                     sleep(5000);   
  38.                     System.out.println("Thread is sleeping...");   
  39.                     setRunning(false);   
  40.                 }   
  41.             }   
  42.         } catch (InterruptedException e) {   
  43.             System.out.println("Interrupt");   
  44.         }   
  45.     }   
  46. }   
class WorkThread extends Thread {
	private boolean runningFlag;

	private String argument;

	public boolean isRunning() {
		return runningFlag;
	}

	public synchronized void setRunning(boolean flag) {
		runningFlag = flag;
		if (flag)
			this.notify();
	}

	public String getArgument() {
		return this.argument;
	}

	public void setArgument(String string) {
		argument = string;
	}

	public WorkThread(int threadNumber) {
		runningFlag = false;
		System.out.println("thread " + threadNumber + "started.");
	}

	public synchronized void run() {
		try {
			while (true) {
				if (!runningFlag) {
					this.wait();
				} else {
					System.out.println("processing " + getArgument()
							+ "... done.");
					sleep(5000);
					System.out.println("Thread is sleeping...");
					setRunning(false);
				}
			}
		} catch (InterruptedException e) {
			System.out.println("Interrupt");
		}
	}
}



(4)管理线程池

Java代码 复制代码
  1. import java.util.*;   
  2.   
  3. class ThreadPoolManager {   
  4.        
  5.     private int maxPools;   
  6.     private int minPools;   
  7.     private int checkThreadPeriod;   
  8. //  private java.util.Timer timer = null;   
  9.     public Vector vector;   
  10.   
  11.     @SuppressWarnings("unchecked")   
  12.     public ThreadPoolManager() {   
  13.         setMaxPools(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("maxPools")));   
  14.         setMinPools(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("minPools")));   
  15.         setCheckThreadPeriod(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("checkThreadPeriod")));   
  16.         System.out.println("Starting thread pool...");   
  17.         vector = new Vector();   
  18.         for (int i = 1; i <= minPools; i++) {   
  19.             WorkThread thread = new WorkThread(i);   
  20.             vector.addElement(thread);   
  21.             thread.start();   
  22.         }   
  23. //      timer = new Timer(true);   
  24. //      timer.schedule(new CheckThreadTask(this),0,checkThreadPeriod);   
  25.     }   
  26.   
  27.     @SuppressWarnings("unchecked")   
  28.     public void process(String argument) {   
  29.         int i;   
  30.         for (i = 0; i < vector.size(); i++) {   
  31.                
  32.             WorkThread currentThread = (WorkThread) vector.elementAt(i);   
  33.             if (!currentThread.isRunning()) {   
  34.                 System.out.println("Thread " + (i + 1) + " is processing:"  
  35.                         + argument);   
  36.                 currentThread.setArgument(argument);   
  37.                 currentThread.setRunning(true);   
  38.                 return;   
  39.             }   
  40.                
  41.             if(i == vector.size()-1){//没的空闲线程了,就新建一个   
  42.                 if(vector.size() < maxPools){   
  43.                     WorkThread thread = new WorkThread(i);   
  44.                     vector.addElement(thread);   
  45.                     thread.setArgument(argument);   
  46.                     thread.setRunning(true);   
  47.                     thread.start();   
  48.                 }   
  49.             }   
  50.         }   
  51.            
  52.         if (i == maxPools) {   
  53.             System.out.println("pool is full, try in another time.");   
  54.         }   
  55.     }   
  56.   
  57.     public int getCheckThreadPeriod() {   
  58.         return checkThreadPeriod;   
  59.     }   
  60.   
  61.     public void setCheckThreadPeriod(int checkThreadPeriod) {   
  62.         this.checkThreadPeriod = checkThreadPeriod;   
  63.     }   
  64.   
  65.     public int getMaxPools() {   
  66.         return maxPools;   
  67.     }   
  68.   
  69.     public void setMaxPools(int maxPools) {   
  70.         this.maxPools = maxPools;   
  71.     }   
  72.   
  73.     public int getMinPools() {   
  74.         return minPools;   
  75.     }   
  76.   
  77.     public void setMinPools(int minPools) {   
  78.         this.minPools = minPools;   
  79.     }   
  80. }// end of class ThreadPoolManager   
import java.util.*;

class ThreadPoolManager {
	
	private int maxPools;
	private int minPools;
	private int checkThreadPeriod;
//	private java.util.Timer timer = null;
	public Vector vector;

	@SuppressWarnings("unchecked")
	public ThreadPoolManager() {
		setMaxPools(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("maxPools")));
		setMinPools(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("minPools")));
		setCheckThreadPeriod(Integer.parseInt(XMLReader.getInstance().getThreadPoolPara("checkThreadPeriod")));
		System.out.println("Starting thread pool...");
		vector = new Vector();
		for (int i = 1; i <= minPools; i++) {
			WorkThread thread = new WorkThread(i);
			vector.addElement(thread);
			thread.start();
		}
//		timer = new Timer(true);
//		timer.schedule(new CheckThreadTask(this),0,checkThreadPeriod);
	}

	@SuppressWarnings("unchecked")
	public void process(String argument) {
		int i;
		for (i = 0; i < vector.size(); i++) {
			
			WorkThread currentThread = (WorkThread) vector.elementAt(i);
			if (!currentThread.isRunning()) {
				System.out.println("Thread " + (i + 1) + " is processing:"
						+ argument);
				currentThread.setArgument(argument);
				currentThread.setRunning(true);
				return;
			}
			
			if(i == vector.size()-1){//没的空闲线程了,就新建一个
				if(vector.size() < maxPools){
					WorkThread thread = new WorkThread(i);
					vector.addElement(thread);
					thread.setArgument(argument);
					thread.setRunning(true);
					thread.start();
				}
			}
		}
		
		if (i == maxPools) {
			System.out.println("pool is full, try in another time.");
		}
	}

	public int getCheckThreadPeriod() {
		return checkThreadPeriod;
	}

	public void setCheckThreadPeriod(int checkThreadPeriod) {
		this.checkThreadPeriod = checkThreadPeriod;
	}

	public int getMaxPools() {
		return maxPools;
	}

	public void setMaxPools(int maxPools) {
		this.maxPools = maxPools;
	}

	public int getMinPools() {
		return minPools;
	}

	public void setMinPools(int minPools) {
		this.minPools = minPools;
	}
}// end of class ThreadPoolManager



(5)调用

Java代码 复制代码
  1. public static void main(String[] args) {   
  2.     try {   
  3.         BufferedReader br = new BufferedReader(new InputStreamReader(   
  4.                 System.in));   
  5.         String s;   
  6.         ThreadPoolManager manager = new ThreadPoolManager();   
  7.         while ((s = br.readLine()) != null) {   
  8.             manager.process(s);   
  9.         }   
  10.     } catch (IOException e) {   
  11.     }   
  12. }  
	public static void main(String[] args) {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			String s;
			ThreadPoolManager manager = new ThreadPoolManager();
			while ((s = br.readLine()) != null) {
				manager.process(s);
			}
		} catch (IOException e) {
		}
	}



(6)具有线程池的工作队列

    我们通常想要的是同一组固定的工作线程相结合的工作队列，它使用 wait() 和 notify() 来通知等待线程新的工作已经到达了。该工作队列通常被实现成具有相关监视器对象的某种链表。

Java代码 复制代码
  1. public class WorkQueue   
  2. {   
  3.     private final int nThreads;   
  4.     private final PoolWorker[] threads;   
  5.     private final LinkedList queue;   
  6.     public WorkQueue(int nThreads)   
  7.     {   
  8.         this.nThreads = nThreads;   
  9.         queue = new LinkedList();   
  10.         threads = new PoolWorker[nThreads];   
  11.         for (int i=0; i<nThreads; i++) {   
  12.             threads[i] = new PoolWorker();   
  13.             threads[i].start();   
  14.         }   
  15.     }   
  16.     public void execute(Runnable r) {   
  17.         synchronized(queue) {   
  18.             queue.addLast(r);   
  19.             queue.notify();   
  20.         }   
  21.     }   
  22.     private class PoolWorker extends Thread {   
  23.         public void run() {   
  24.             Runnable r;   
  25.             while (true) {   
  26.                 synchronized(queue) {   
  27.                     while (queue.isEmpty()) {   
  28.                         try  
  29.                         {   
  30.                             queue.wait();   
  31.                         }   
  32.                         catch (InterruptedException ignored)   
  33.                         {   
  34.                         }   
  35.                     }   
  36.                     r = (Runnable) queue.removeFirst();   
  37.                 }   
  38.                 // If we don't catch RuntimeException,    
  39.                 // the pool could leak threads   
  40.                 try {   
  41.                     r.run();   
  42.                 }   
  43.                 catch (RuntimeException e) {   
  44.                     // You might want to log something here   
  45.                 }   
  46.             }   
  47.         }   
  48.     }   
  49. }  
public class WorkQueue
{
    private final int nThreads;
    private final PoolWorker[] threads;
    private final LinkedList queue;
    public WorkQueue(int nThreads)
    {
        this.nThreads = nThreads;
        queue = new LinkedList();
        threads = new PoolWorker[nThreads];
        for (int i=0; i<nThreads; i++) {
            threads[i] = new PoolWorker();
            threads[i].start();
        }
    }
    public void execute(Runnable r) {
        synchronized(queue) {
            queue.addLast(r);
            queue.notify();
        }
    }
    private class PoolWorker extends Thread {
        public void run() {
            Runnable r;
            while (true) {
                synchronized(queue) {
                    while (queue.isEmpty()) {
                        try
                        {
                            queue.wait();
                        }
                        catch (InterruptedException ignored)
                        {
                        }
                    }
                    r = (Runnable) queue.removeFirst();
                }
                // If we don't catch RuntimeException, 
                // the pool could leak threads
                try {
                    r.run();
                }
                catch (RuntimeException e) {
                    // You might want to log something here
                }
            }
        }
    }
}



大多数专家建议使用 notifyAll() 而不是 notify() ，而且理由很充分：使用 notify() 具有难以捉摸的风险，只有在某些特定条件下使用该方法才是合适的。另一方面，如果使用得当， notify() 具有比 notifyAll() 更可取的性能特征；特别是， notify() 引起的环境切换要少得多，这一点在服务器应用程序中是很重要的。

分享到：
| java socket编程收藏之四(线程池)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java线程池使用后到底要关闭吗

    java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...

    java线程池完整代码

    "Java 线程池完整代码解析" Java 线程池是 Java 语言中的一个重要概念，它允许开发者创建和管理多个线程，以提高程序的并发性和性能。下面是对给定文件的解析，包括 title、description、标签和部分内容的解析。 ...

    java线程池封装j

    Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...

    java线程池知识.ppt

    java线程池知识、

    java线程池实例详细讲解

    Java线程池是一种高效管理线程资源的工具，它能够帮助开发者有效地控制并调度线程，从而提升系统性能，减少系统资源的浪费。在Java中，`ExecutorService`接口是线程池的主要入口，它是`java.util.concurrent`包的一...

    Java线程池使用说明

    Java线程池是Java并发编程中的重要组件，它能够有效地管理和复用线程，从而提高程序的执行效率和降低资源消耗。在JDK 1.5版本之前，Java对线程池的支持非常有限，而在JDK 1.5之后，加入了java.util.concurrent包，...

    java线程池threadpool简单使用源码

    Java线程池（ThreadPool）是Java并发编程中的一个重要概念，它可以帮助我们有效地管理和控制并发执行的任务，从而提高系统的效率和稳定性。线程池通过复用已存在的线程，避免了频繁创建和销毁线程带来的开销，同时也...

    自定义实现Java线程池

    ### 自定义实现Java线程池 #### 一、概述 在深入探讨自定义Java线程池之前，我们先简要回顾一下线程池的基本概念及其重要性。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动...

    java线程池的源码分析.zip

    Java线程池是Java并发编程中的重要组成部分，它在多线程和高并发场景下扮演着关键角色。本文将深入探讨Java线程池的源码分析，并对比不同类型的线程池，以帮助开发者更好地理解和利用这一强大的工具。 首先，我们要...

    Java 线程池.docx

    Java线程池是一种高效管理线程资源的工具，它的出现是为了应对多线程编程中频繁创建和销毁线程带来的性能开销以及资源消耗。在Java中，通过使用线程池，我们可以预先创建一定数量的线程，这些线程在空闲时可以被复用...

    Java线程池与ThreadPoolExecutor.pdf

    Java线程池是Java并发编程中的重要组成部分，它允许开发者管理多个线程并有效地调度任务。线程池通过ThreadPoolExecutor类实现，这是一个高度可配置的工具，能够根据具体需求定制线程的创建、管理和销毁策略。 ...

    Java简单线程池 线程池中文文档

    简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类

    Java 线程池的原理与实现

    Java线程池是一种高级的多线程处理框架，它是Java并发编程中非常重要的一个组件。线程池的原理和实现涉及到操作系统调度、内存管理和并发控制等多个方面。理解线程池的工作原理有助于优化程序性能，避免过度创建和...

    一个通用的Java线程池类

    2.然后根据提示运行java命令执行示例程序，观看线程池的运行结果 目标：Java中多线程技术是一个难点，但是也是一个核心技术。因为Java本身就是一个多线程语言。本人目前在给46班讲授Swing的网络编程--使用Swing来...

    java 线程池实现多并发队列后进先出

    Java线程池是一种高效管理并发任务的机制，它允许开发者预先配置一定数量的线程，以便在处理多个并发任务时能有效地复用这些线程，从而避免了频繁创建和销毁线程带来的开销。在Java中，`java.util.concurrent`包下的...

    基于Java线程池技术实现Knock Knock游戏项目.zip

    基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池...

    JAVA线程池的原理与实现.pdf

    Java线程池是一种高效利用系统资源、管理并发执行任务的机制。它的原理是通过预先创建一组线程，这些线程在任务到来时可以立即执行，而不是每次需要执行任务时都新建线程，从而降低了线程创建和销毁带来的开销。...

    Java线程池及观察者模式解决多线程意外死亡重启问题

    Java线程池是Java并发编程中的重要组成部分，它允许开发者高效地管理多个并发执行的线程，有效地控制系统的资源消耗，提高系统性能和稳定性。在Java中，`java.util.concurrent`包提供了`ExecutorService`接口及其...

    Java 线程池.pptx

    讲述了java线程池的优点，参数，6种线程池的使用场景，线程池用到的handler,线程任务的提交方式等等。

Magicbox
Global site tag (gtag.js) - Google Analytics