Java 如何让线程利用100%的CPU？

我有一个简单的生产者（1）和消费者（从1到50不等）问题，生产者只需在队列中添加元素，消费者就可以读取它。我试图获得100%的CPU利用率

目前我得到20%的利用率。我无法获得100%的CPU利用率。我希望我所有的CPU都能更快地执行操作。我应该看什么

机器：运行Windows8和Java7的i7（第四代-带超线程的四元代码）

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.Semaphore;
/*
 * Purpose is to test system clock granularity
 */

public class ClockGranularity{
        private static final int MaxExecutionTimeMsec = 6;
        //60*1000 milliseconds
        private static float delta = 0.01f;
        //Inter-arrival Time(IAT): in milliseconds
        static final int ArraySize =(int) ((float)MaxExecutionTimeMsec/delta);
        private static final int convertMilliToNano = 1000000;

        private static String getTime() {
                DateFormat format = new SimpleDateFormat("dd-MMM-yy HH:mm:ss");
                Calendar cal = Calendar.getInstance();
                return format.format(cal.getTime());
        }
        /*
         * Invoke 1 producer vs 1,2,3 consumers
         * Write consumer to file
         */
        public static void main(String args[]) {
                ClockGranularity.delta = delta*convertMilliToNano;
                long execStartTime = System.currentTimeMillis();
                long experimentStartTime = System.nanoTime();
                long execDuration, experimentRuntime;
                Buffer requestQueue = new Buffer();
                Producer producer = new Producer(requestQueue);
                Consumer consumer = new Consumer(requestQueue);
                Consumer consumer2 = new Consumer(requestQueue);
                Consumer consumer3 = new Consumer(requestQueue);
                consumer.start();
                consumer2.start();
                consumer3.start();
                do {
                        execDuration = System.currentTimeMillis() - execStartTime;
                        experimentRuntime = System.nanoTime() - experimentStartTime;
                        if(experimentRuntime >= delta) {
                                experimentStartTime = System.nanoTime();
                        producer.run();
                        }
                } while (execDuration <= MaxExecutionTimeMsec);
                consumer.interrupt();
                consumer2.interrupt();
                consumer3.interrupt();
                delta/=convertMilliToNano;
                try {
                        String producerFile = "Producer-" + delta + " msec @" + getTime();
                        printToFile(producerFile,requestQueue.getQueue());
                        String consumerFile = "Consumer-" + delta + " msec@" + getTime();
                        printToFile(consumerFile, consumer.getValidateConsumerArray());
                        consumerFile = "Consumer2-" + delta + " msec@" + getTime();
                        printToFile(consumerFile, consumer2.getValidateConsumerArray());
                        consumerFile = "Consumer3-" + delta + " msec@" + getTime();
                        printToFile(consumerFile, consumer3.getValidateConsumerArray());
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
        public static void printToFile(String outputFileName,Queue<Integer> requestQueue) throws IOException{
                outputFileName = outputFileName.replace(':', '-');
                String lineSeparator = System.lineSeparator();
                File directory = new File("Practice Coding\\src\\ClockGranularity Test results\\Semaphore and Queue\\");
                File file = File.createTempFile(outputFileName, ".txt",directory);
                FileWriter writer = new FileWriter(file);
                writer.append("Index \tQueue Contents" + lineSeparator);
                int size = requestQueue.size();
                String summary = "queue<>" + size;
                for(int i = 0; i<size; i++) {
                        String temp = i + " ticks  \t" + requestQueue.poll();
                        System.out.println(temp);
                        writer.append(temp + lineSeparator);
                }
                writer.append(lineSeparator + "Summary: " + lineSeparator);
                writer.append(summary + lineSeparator);
                System.out.println(outputFileName + " " + summary);
                writer.close();
        }
}
class Buffer {
        private Queue<Integer> requestsQueue;
        Semaphore accessQueue;
        Buffer() {
                requestsQueue = new LinkedList<Integer>();
                accessQueue = new Semaphore(1);
        }
        public void put(Integer tick) throws InterruptedException {
                accessQueue.acquire();
                requestsQueue.add(tick);
                accessQueue.release();
        }
        public synchronized int get() throws InterruptedException {
                int tick;
                while(requestsQueue.size() == 0) {
                        try {
                                wait();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
                accessQueue.acquire();
                tick = requestsQueue.poll();
                accessQueue.release();
                return tick;
        }
        public Queue<Integer> getQueue() {
                return requestsQueue;
        }
}

class Consumer extends Thread{
        private Buffer bufferQueue;
        private Queue<Integer> validateConsumer;
        Consumer(Buffer requestQueue) {
                bufferQueue = requestQueue;
                validateConsumer = new LinkedList<Integer>();
        }
        public void run() {
                while(true) {
                        int i;
                        try {
                                i = bufferQueue.get();
                                validateConsumer.add(i);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
        public Queue<Integer> getValidateConsumerArray() {
                return validateConsumer;
        }
}

class Producer extends Thread{
        public int tick = 0;
        private Buffer bufferQueue;
        Producer(Buffer requestQueue) {
                bufferQueue = requestQueue;    
        }
        public void run() {
                try {
                        bufferQueue.put(tick++);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
        }
}

导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.text.DateFormat；
导入java.text.simpleDataFormat；
导入java.util.Calendar；
导入java.util.LinkedList；
导入java.util.Queue；
导入java.util.concurrent.Semaphore；
/*
*目的是测试系统时钟粒度
*/
公共类时钟粒度{
私有静态final int MaxExecutionTimeMsec=6；
//60*1000毫秒
专用静态浮动增量=0.01f；
//到达时间（IAT）：以毫秒为单位
静态最终整数数组化=（整数）（（浮点）MaxExecutionTimeMsec/delta）；
私有静态最终整数转换Millitonano=1000000；
私有静态字符串getTime（）{
DateFormat格式=新的简化格式（“dd-MMM-yy-HH:mm:ss”）；
Calendar cal=Calendar.getInstance（）；
返回format.format（cal.getTime（））；
}
/*
*调用1个生产者对1,2,3个消费者
*将消费者写入文件
*/
公共静态void main（字符串参数[]）{
ClockGranularity.delta=delta*convertMilliToNano；
long execStartTime=System.currentTimeMillis（）；
long experimentStartTime=System.nanoTime（）；
执行时间长，运行时间短；
缓冲区请求队列=新缓冲区（）；
生产者生产者=新生产者（请求队列）；
消费者=新消费者（请求队列）；
消费者消费者2=新消费者（请求队列）；
消费者3=新消费者（请求队列）；
consumer.start（）；
consumer2.start（）；
consumer3.start（）；
做{
execDuration=System.currentTimeMillis（）-execStartTime；
experimentRuntime=System.nanoTime（）-experimentStartTime；
如果（运行时>=增量）{
experimentStartTime=System.nanoTime（）；
producer.run（）；
}
}而（execDuration您可以做的事情：

-与其执行繁忙循环（时间查询可能会降低利用率），不如像处理消费者一样将生产者代码设置为while（true），将主线程睡眠为MaxExecutionTimeMsec时间，并像处理消费者一样对生产者执行中断，看看是否有区别

-这与它通常的用法相反，但是运行一个特殊的探查器，看看在哪里花费了多少时间。如果它不是一个业务部分（比如等待锁获取），请在那里重新设计

-如果性能是关键，并且您有一个多核p，那么您可能需要研究自旋锁
处理器。在某些摊销的情况下，上下文切换可能比旋转锁更昂贵。
您的
缓冲区实现是错误的。它本质上序列化了读/写操作，因此性能很差。您需要使用或实现一个。他以一种糟糕的方式重新发明了ConcurrentLinkedQueue。正确的答案是：使用ConcurrentLinkedQueue。用ConcurrentLinkedQueue替换缓冲区，您就完成了。不确定为什么会锁定，这是一个非常简单的问题，只有一个答案。我知道可能有很多可能的答案。我愿意全部尝试。我对线程相当陌生，很难理解我遗漏了什么。