发送邮件队列

今天药忘吃喽~ 2022-06-10 03:06 66阅读 0赞

package com.jswhzl.lease.common.util;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import com.jswhzl.lease.entity.SendEmail;
    
    /**
     * @author Administrator
     *
     */
    @Service
    public class ThreadPool {
    	// 线程池中默认的个数
    	private static int worker_num = 5;
    	// 工作线程
    	private workThread[] workThrads;
    
    	// 任务队列 作为一个缓冲 ，list线程不安全
    	private static List<Runnable> taskQueue = new LinkedList<Runnable>();
    	// 已完成任务数量
    	public static volatile int i = 0;
    	
    	
        @Autowired
    	private static ThreadPool threadPool;
    	
    	
    	private static Email email = null; 
    		
    		
    	 
    	
    	
    
    	// 单台模式获得一个指定线程个数的线程池，
    	@SuppressWarnings("static-access")
    	private static ThreadPool getThreadPool(int worker_num1) {
    		if (worker_num1 <= 0)
    			worker_num1 = threadPool.worker_num;
    		if (threadPool == null)
    			threadPool = new ThreadPool();
    		return threadPool;
    	}
    
    	// 创建线程池
    	@Autowired
    	public ThreadPool() {
    		//threadPool.worker_num = 5;
    		workThrads = new workThread[5];
    		for (int i = 0; i < 5; i++) {
    			workThrads[i] = new workThread();
    			workThrads[i].start();
    		}
    	}
    
    	// 批量执行任务，其实只是把任务加入任务队列，什么时候执行有线程池管理器决定
    	public void execute(Runnable[] task) {
    		synchronized (taskQueue) {
    			for (Runnable t : task)
    				taskQueue.add(t);
    			    taskQueue.notify();
    		}
    	}
    
    	// 内部类，工作线程
    	private class workThread extends Thread {
    		private boolean isRunning = true;
    
    		public void run() {
    			Runnable r = null;
    			while (isRunning) {
    				synchronized (taskQueue) {
    					while (isRunning && taskQueue.isEmpty()) {
    						try {
    							taskQueue.wait(1000);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    					}
    					if (!taskQueue.isEmpty())
    						r = taskQueue.remove(0);// 取出任务
    				}
    				if (r != null) {
    					r.run();
    				}
    				r = null;
    			}
    		}
    
    		// 停止工作，让线程自然执行run方法自然结束
    		public void stopWorker() {
    			isRunning = false;
    		}
    
    	}
    	
    
    	// 销毁线程池
    	public void destroy() {
    		
    		while (!taskQueue.isEmpty()) {
    			
    		// 如果还有任务没执行完成，就先睡会吧
    			try {
    				Thread.sleep(2000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		// 工作线程停止工作，且置为null
    		for (int i = 0; i < worker_num; i++) {
    			workThrads[i].stopWorker();
    			workThrads[i] = null;
    		}
    		
    		threadPool = null;
    		taskQueue.clear();// 清空任务队列
          
    	}
    
    	@SuppressWarnings("static-access")
    	public void emailPool(SendEmail sendEmail) throws InterruptedException {
    		/* this.sendEmail=sendEmail; */
    		ThreadPool t = threadPool.getThreadPool(5);
    		
    		List<String> recipients = sendEmail.getRecipients();
    		Runnable[] tasks = null; // new Runnable[]{c,c,c};
    		List<String> recis = null;
    		Runnable c = null;
    		for (int a = 0; a < recipients.size(); a++) {
    			recis = new ArrayList<String>();
    			recis.add(recipients.get(a));
    			Thread.sleep(10);
    			sendEmail.setRecipients(recis);
    				c = () -> {
    					try {
    						Email mail = email.getInstance();
    						mail.send(sendEmail,null);
    						i++;
    					} catch (Exception e) {
    						e.printStackTrace();
    					}
    					
    				};
    	        tasks = new Runnable[] { c };
    			t.execute(tasks);
    			Thread.sleep(500);
    			
    		}
    		t.destroy();
    		Thread.sleep(20);
    		System.out.println(t);
    	}
    
    	public String toString() {
    		return "工作线程数量:" + worker_num + "完成任务数量：" + i + "等待任务数量：" + taskQueue.size();
    	}
    						
    						
    
    
    
    
    
    
    
    
    }