集合操作与线程池应用-优快云博客

本文介绍使用LinkedList与ArrayList的不同场景，展示了如何通过CollectionTest类实现元素的添加与批量移除，并利用线程池（ExecutorService）进行并发处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是集合的类，linkedList删除操作和增加操作比较快；
ArrayList 查找比较快，增加删除比linlList相对慢
；
package org;

import java.util.LinkedList;
import java.util.List;

public class CollectionTest {
	private List list = new LinkedList();

	public List getList() {
		return list;
	}

	public void setList(List list) {
		this.list = list;
	}
	public List addList(Object obj){
		boolean flag = list.contains(obj);
		if(flag){
			System.out.println("您已提交，请稍后");
			return null;
		}else{
			flag = list.add(obj);
			if(flag){
				System.out.println("添加队列成功");
				return list;
			}else{
				System.out.println("添加队列失败");
				return null;
			}
		}
	}
	/**
	 * dui列多个弹出
	 * @param length
	 * @return
	 */
	public Object[] remove(int length) {
		Object[] str = new Object[length];
		if( length > 0){
			for(int i = 0;i < length;i++){
				System.out.println("原集合"+toString());
				//移除数据
				str[i] = list.remove(0).toString();
				
				System.out.println("remove: "+str[i]);
				System.out.println("删除后的集合: "+toString());
				System.out.println();
			}
		}else{
			return null;
		}
//		System.out.println("加入数组的数据："+str.toString());
		return str;
	}
	/**
	 * 队列单个弹出
	 * @return
	 */
	public String remove() {
		System.out.println(list.toString());
		return (String) list.remove(0);
	}

	@Override
	public String toString() {
		return list.toString();
	}

	public int size() {
		return list.size();
	}
	
	public boolean isEmpty(){
		return list.isEmpty();
	}
	
}

线程类

package org.thread;

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

import org.CollectionTest;

public class ThreadUtil {
	
	private CollectionTest list = null;
	
	//private static ExecutorService fixedThreadPool= Executors.newFixedThreadPool(1);
//	ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
	ExecutorService fixedThreadPool = Executors.newCachedThreadPool(); 
	
	//ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
	public void  startOne(){
		if( !list.isEmpty()){
//			for (int i = 0; i < list.size(); i++) {  
////				System.out.println("l集合的长度："+list.size());
//				  final int index = i;
////				  final String str = list.remove();
////				  System.out.println(str);
//				  fixedThreadPool.execute(new Runnable() {  
//					  public void run() {  
//						  try {  
////							  System.out.println(index+": "+str ); 
//							  System.out.println(index ); 
//	 						  Thread.sleep(2000);  
//						  } catch (InterruptedException e) {  
//							  e.printStackTrace();  
//						  }  
//					  }  
//				  });  
//			}  
			fixedThreadPool.execute(new Runnable(){

				public void run() {
					
					for (int i = 0; i < list.size(); i++) { 
						final int index = i;
						final String str = list.remove();
						try {
							System.out.println(index + ":"+str);
							Thread.sleep(1000);
							run();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
			});
		}else{
			System.out.println("集合为空");
		}
		
	}
	public void  startMany(){
		if( !list.isEmpty()){
			
			fixedThreadPool.execute(new Runnable(){
				public void run() {
					if(list.isEmpty()){
						return;
					}else{
						try {
							System.out.println(list.toString());
							 Object[] str = null;
							if(list.size() < 3){
								str = list.remove(list.size());
							}else{
								str = list.remove(3);
							}
//							System.out.println(index );
							for(Object obj : str){
								System.out.println(obj);
							}
							Thread.sleep(1000);
							run();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
			});
		}else{
			System.out.println("集合为空");
		}
		
	}
	public CollectionTest getList() {
		return list;
	}
	public void setList(CollectionTest list) {
		this.list = list;
	}
}

main方法

package org.thread;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import org.CollectionTest;

public class ExecutorsTest {
//   public static void main(String[] args) {
//       ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
//       for (int i = 0; i < 10; i++) {
//           final int index = i;
//           try {
//               Thread.sleep(index * 1000);
//           } catch (InterruptedException e) {
//               e.printStackTrace();
//           }
//           cachedThreadPool.execute(new Runnable() {
//               public void run() {
//                   System.out.println(index);
//               }
//           });
//       }
//   }
//   newFixedThreadPool
//   创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
   public static void main(String[] args) {
       CollectionTest list= new CollectionTest();
       list.addList("sss");
       list.addList("aaa");
       list.addList("eee");
       list.addList("rrr");
       list.addList("fff");
       list.addList("yyy");
       list.addList("uuuu");
       list.addList("iii");
       list.addList("ooo");
       list.addList("ppp");
//       list.remove(7);
       ThreadUtil th = new ThreadUtil();
       th.setList(list);
       th.startMany();
   }
   //newScheduledThreadPool
   //创建一个定长线程池，支持定时及周期性任务执行
//   public static void main(String[] args) {
//          ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
//          scheduledThreadPool.schedule(new Runnable() {
//           public void run() {
//            System.out.println("delay 3 seconds");
//           }
//          }, 3, TimeUnit.SECONDS);
//       }
}