有执行器和没有执行器的多线程之间的区别 [英] Difference between multithreading with and without Executor
本文介绍了有执行器和没有执行器的多线程之间的区别的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我试图找出使用执行程序(以维护线程池)在普通多线程与多线程之间的性能差异.
I am trying to find out about the performance difference between normal multithreading and multithreading using executor (to maintain a thread pool).
下面是两者的代码示例.
The below are code examples for both.
没有执行程序代码(具有多线程):
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.ThreadMXBean;
import java.util.List;
public class Demo1 {
public static void main(String arg[]) {
Demo1 demo = new Demo1();
Thread t5 = new Thread(new Runnable() {
public void run() {
int count=0;
// Thread.State;
// System.out.println("ClientMsgReceiver started-----");
Demo1.ChildDemo obj = new Demo1.ChildDemo();
while(true) {
// System.out.println("Threadcount is"+Thread);
// System.out.println("count is"+(count++));
Thread t=new Thread(obj);
t.start();
ThreadMXBean tb = ManagementFactory.getThreadMXBean();
List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean pool : pools) {
MemoryUsage peak = pool.getPeakUsage();
System.out.format("Peak %s memory used: %,d%n",
pool.getName(), peak.getUsed());
System.out.format("Peak %s memory reserved: %,d%n",
pool.getName(), peak.getCommitted());
}
System.out.println("Current Thread Count"+ tb.getThreadCount());
System.out.println("Peak Thread Count"+ tb.getPeakThreadCount());
System.out.println("Current_Thread_Cpu_Time "
+ tb.getCurrentThreadCpuTime());
System.out.println("Daemon Thread Count" +tb.getDaemonThreadCount());
}
// ChatLogin = new ChatLogin();
}
});
t5.start();
}
static class ChildDemo implements Runnable {
public void run() {
try {
// System.out.println("Thread Started with custom Run method");
Thread.sleep(100000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally {
System.out.println("A" +Thread.activeCount());
}
}
}
}
具有执行程序(多线程):
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.ThreadMXBean;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Executor_Demo {
public static void main(String arg[]) {
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(10);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
10, 100, 10, TimeUnit.MICROSECONDS, queue);
Executor_Demo demo = new Executor_Demo();
executor.execute(new Runnable() {
public void run() {
int count=0;
// System.out.println("ClientMsgReceiver started-----");
Executor_Demo.Demo demo2 = new Executor_Demo.Demo();
BlockingQueue<Runnable> queue1 = new ArrayBlockingQueue<Runnable>(1000);
ThreadPoolExecutor executor1 = new ThreadPoolExecutor(
1000, 10000, 10, TimeUnit.MICROSECONDS, queue1);
while(true) {
// System.out.println("Threadcount is"+Thread);
// System.out.println("count is"+(count++));
Runnable command= new Demo();
// executor1.execute(command);
executor1.submit(command);
// Thread t=new Thread(demo2);
// t.start();
ThreadMXBean tb = ManagementFactory.getThreadMXBean();
/* try {
executor1.awaitTermination(100, TimeUnit.MICROSECONDS);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} */
List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
for (MemoryPoolMXBean pool : pools) {
MemoryUsage peak = pool.getPeakUsage();
System.out.format("Peak %s memory used: %,d%n",
pool.getName(), peak.getUsed());
System.out.format("Peak %s memory reserved: %,d%n",
pool.getName(), peak.getCommitted());
}
System.out.println("daemon threads"+tb.getDaemonThreadCount());
System.out.println("All threads"+tb.getAllThreadIds());
System.out.println("current thread CPU time "
+ tb.getCurrentThreadCpuTime());
System.out.println("current thread user time "
+ tb.getCurrentThreadUserTime());
System.out.println("Total started thread count "
+ tb.getTotalStartedThreadCount());
System.out.println("Current Thread Count"+ tb.getThreadCount());
System.out.println("Peak Thread Count"+ tb.getPeakThreadCount());
System.out.println("Current_Thread_Cpu_Time "
+ tb.getCurrentThreadCpuTime());
System.out.println("Daemon Thread Count"
+ tb.getDaemonThreadCount());
// executor1.shutdown();
}
//ChatLogin = new ChatLogin();
}
});
executor.shutdown();
}
static class Demo implements Runnable {
public void run() {
try {
// System.out.println("Thread Started with custom Run method");
Thread.sleep(100000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally {
System.out.println("A" +Thread.activeCount());
}
}
}
}
示例输出
当我同时运行两个程序时，发现执行程序比普通的多线程处理更昂贵.为什么会这样?
When I run both programs, it turns out the executor is more expensive than normal multithreading. why is this so?
鉴于此，执行程序的确切用途是什么?我们使用执行程序来管理线程池.
And given this, what is the use of executor exactly? We use the executor to manage thread pools.
我希望执行程序能够比普通的多线程提供更好的结果.
I would have expected the executor to give better results than normal multithreading.
基本上，我这样做是因为我需要使用具有多线程的套接字编程来处理数百万个客户端.
Basically I'm doing this as I need to handle millions of clients using socket programming with multithreading.
任何建议都会有所帮助.
Any suggestions will be helpful.
推荐答案
要了解事物如何扩展，我将尝试将监视成本保持在最低水平，并将小数目与大数目进行比较.
To see how something scales, I would try to keep the cost of monitoring to a minimum and I would compare a small number to a large number.
public class Executor_Demo {
public static void main(String... arg) throws ExecutionException, InterruptedException {
int nThreads = 5100;
ExecutorService executor = Executors.newFixedThreadPool(nThreads, new DaemonThreadFactory());
List<Future<Results>> futures = new ArrayList<Future<Results>>();
for (int i = 0; i < nThreads; i++) {
futures.add(executor.submit(new BackgroundCallable()));
}
Results result = new Results();
for (Future<Results> future : futures) {
result.merge(future.get());
}
executor.shutdown();
result.print(System.out);
}
static class Results {
private long cpuTime;
private long userTime;
Results() {
final ThreadMXBean tb = ManagementFactory.getThreadMXBean();
cpuTime = tb.getCurrentThreadCpuTime();
userTime = tb.getCurrentThreadUserTime();
}
public void merge(Results results) {
cpuTime += results.cpuTime;
userTime += results.userTime;
}
public void print(PrintStream out) {
ThreadMXBean tb = ManagementFactory.getThreadMXBean();
List<MemoryPoolMXBean> pools = ManagementFactory.getMemoryPoolMXBeans();
for (int i = 0, poolsSize = pools.size(); i < poolsSize; i++) {
MemoryPoolMXBean pool = pools.get(i);
MemoryUsage peak = pool.getPeakUsage();
out.format("Peak %s memory used:\t%,d%n", pool.getName(), peak.getUsed());
out.format("Peak %s memory reserved:\t%,d%n", pool.getName(), peak.getCommitted());
}
out.println("Total thread CPU time\t" + cpuTime);
out.println("Total thread user time\t" + userTime);
out.println("Total started thread count\t" + tb.getTotalStartedThreadCount());
out.println("Current Thread Count\t" + tb.getThreadCount());
out.println("Peak Thread Count\t" + tb.getPeakThreadCount());
out.println("Daemon Thread Count\t" + tb.getDaemonThreadCount());
}
}
static class DaemonThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
static class BackgroundCallable implements Callable<Results> {
@Override
public Results call() throws Exception {
Thread.sleep(100);
return new Results();
}
}
}
用-XX:MaxNewSize=64m测试时(这限制了临时存储空间的大小会增加)
when tested with -XX:MaxNewSize=64m (this limits the size temporary memory spaces will increase)
100 threads
Peak Code Cache memory used: 386,880
Peak Code Cache memory reserved: 2,555,904
Peak PS Eden Space memory used: 41,280,984
Peak PS Eden Space memory reserved: 50,331,648
Peak PS Survivor Space memory used: 0
Peak PS Survivor Space memory reserved: 8,388,608
Peak PS Old Gen memory used: 0
Peak PS Old Gen memory reserved: 192,675,840
Peak PS Perm Gen memory used: 3,719,616
Peak PS Perm Gen memory reserved: 21,757,952
Total thread CPU time 20000000
Total thread user time 20000000
Total started thread count 105
Current Thread Count 93
Peak Thread Count 105
Daemon Thread Count 92
5100 threads
Peak Code Cache memory used: 425,728
Peak Code Cache memory reserved: 2,555,904
Peak PS Eden Space memory used: 59,244,544
Peak PS Eden Space memory reserved: 59,244,544
Peak PS Survivor Space memory used: 2,949,152
Peak PS Survivor Space memory reserved: 8,388,608
Peak PS Old Gen memory used: 3,076,400
Peak PS Old Gen memory reserved: 192,675,840
Peak PS Perm Gen memory used: 3,787,096
Peak PS Perm Gen memory reserved: 21,757,952
Total thread CPU time 810000000
Total thread user time 150000000
Total started thread count 5105
Current Thread Count 5105
Peak Thread Count 5105
Daemon Thread Count 5104
主要增加是使用的旧gen的增加〜3 MB或每个线程大约6 KB.并且CPU使用了956毫秒或每个线程约0.2毫秒.
The main increase is the increase in old gen used ~ 3 MB or about 6 KB per thread. and the CPU used by 956 ms or about 0.2 ms per thread.
在第一个示例中，您正在创建一个线程，在第二个示例中，您正在创建1000个线程.
In your first example, you are creating one thread, in the second you are creating 1000.
您正在执行的输出似乎是大部分工作，第二种情况下的输出要比第一种情况多.
The output you are performing appears to be most of the work and you have much more output in the second case than the first.
您需要确保测试和监视的重量远远少于您要监视/测量的重量.
You need to be sure your testing and monitoring is far more light weight than want you are trying to monitor/measure.
这篇关于有执行器和没有执行器的多线程之间的区别的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
