ArrayBlockingQueue take()操作

 内部类实现Runable接口，通过while(true)循环来执行业务逻辑，首先通过ArrayBlockingQueue.take()来获取需要执行的任务，当队列为空，内部会进入空循环等待，避免过高耗费cpu。

业务类： 

package com.java.innerclassthread ;

import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ResourceSynchronizeTaskExecutor {
	
	BlockingQueue<String> taskQueue;

	public ResourceSynchronizeTaskExecutor() {
		System.out.println("start [RESOURCE SYNCHRONIZE TASK Executor] ...");
		taskQueue = new ArrayBlockingQueue<String>(200);
		for (int i = 0; i < 5; i++) {
			new Thread(new ResourceSynchronizeWorker()).start();
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				System.out.println("start sync worker err");
			}
		}
	}

//	@Override
	public void execute(String String) {
	}

//	@Override
	public void execute(List<String> Strings) {
		for (String String : Strings) {
			try {
				taskQueue.put(String);
				
			} catch (Exception e) {
				System.out.println("put queue error");
			}
		}
	}

	class ResourceSynchronizeWorker implements Runnable {

		String String;

		boolean isRunning = true;

		public ResourceSynchronizeWorker() {
		}

		public void run() {
			System.out.println("sync start...");
			while (isRunning) {
				try {
					System.out.println("xunhuanzhixing................");
					String = taskQueue.take();
				} catch (Exception e) {
					
				}
			}
		}
	}

}

测试类，运行时首先从内存中获取被执行类的实例，如果为空，则实例化： 

package com.java.innerclassthread;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class InnerClassThreadTest {
	
	Map<String,ResourceSynchronizeTaskExecutor> cache = new HashMap<String,ResourceSynchronizeTaskExecutor>();
	
	public static void main(String[] args) {
		new InnerClassThreadTest().running(); 
	}
	
	public void running(){
		boolean isRunning = true;
		
		while(isRunning){
			String [] StringActions = new String [(int)(Math.random()*20)];
			
			for (int index = 0 ;index <StringActions.length ;index ++){
				StringActions[index] = "index"+index;
			}
			ResourceSynchronizeTaskExecutor ResourceSynchronizeTaskExecutor = getCache ();
			List<String> theStrings = new ArrayList<String> ();
			theStrings.add(new String()) ;
			ResourceSynchronizeTaskExecutor.execute(theStrings);
			
			if (StringActions.length < 10){
				System.out.println("length:"+StringActions.length);
				try {
					Thread.sleep(10000);
				} catch (Exception e) {
					
				}
			}
		}
	}
	
	public ResourceSynchronizeTaskExecutor getCache(){
		ResourceSynchronizeTaskExecutor executor = cache.get("ResourceSynchronizeTaskExecutor.class");
		
		if (executor == null ){
			executor = new ResourceSynchronizeTaskExecutor();
			cache.put("ResourceSynchronizeTaskExecutor.class", executor) ;
		}
		return executor ;
	}
	
}

JDK 中ArrayBlockingQueue take()方法源码：

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

当使用take 从queue中获取任务时，当任务为空，则释放cpu进行等待；

当使用pull()来从queue中获取任务进行处理时 ，如果count==0，则直接返回null，造成的结果时，如果在while(true){}中执行获取任务操作，会造成cpu占用率100%。