关于起线程的数目

时间 2019-12-10

标签关于线程数目繁體版

原文原文链接

对于多线程的使用，通常对于起多少个线程数目，对于这点我通常会考虑CPU核心数，消耗的资源以及是不是瓶颈html

下面我用一个示例大体解释下个人思路java

public class Demo {

	BlockingQueue<String> urlQueue = new ArrayBlockingQueue<String>(1024);
	BlockingQueue<Html> htmlQueue = new ArrayBlockingQueue<Html>(1024);
	BlockingQueue<Meta> metaQueue = new ArrayBlockingQueue<Meta>(1024);
	
	public void execute() throws InterruptedException {
		new Thread(new QueryThread()).start();
		
		Thread[] spiders = new Thread[5];
		for (int x = 0; x < spiders.length; x++) {
			spiders[x] = new  Thread(new SpiderThread());
			spiders[x].start();
		}
		
		Thread[] parsers = new Thread[5];
		for (int x = 0; x < parsers.length; x++) {
			parsers[x] = new  Thread(new ParserThread());
			parsers[x].start();
		}
		
		Thread[] writers = new Thread[3];
		for (int x = 0; x < writers.length; x++) {
			writers[x] = new  Thread(new WriteThread());
			writers[x].start();
		}
		
		//等待Spider线程结束
		for (int x = 0; x < spiders.length; x++) {
			spiders[x].join();
		}
		
		//往htmlQueue通信队列中放入结束信号
		putEmptySingeleToHtmlQueue();
		
		//等待Parser线程结束
		for (int x = 0; x < parsers.length; x++) {
			parsers[x].join();
		}

		//往metaQueue通信队列中放入结束信号
		putEmptySingeleToMetaQueue();
		
		//等待Writer线程结束
		for (int x = 0; x < writers.length; x++) {
			writers[x].join();
		}
		
		//Writer线程所有结束，程序结束
	}

	
	private void putEmptySingeleToMetaQueue() throws InterruptedException {
		Meta meta = new Meta();
		meta.setEmpty(true);
		metaQueue.put(meta);
	}


	private void putEmptySingeleToHtmlQueue() throws InterruptedException {
		Html empty = new Html();
		empty.setEmpty(true);
		htmlQueue.put(empty);
	}


	class QueryThread implements Runnable{
		
		@Override
		public void run() {
			try {
				String url = null;
				while ((url = getUrl()) != null) {
					if (url.length() == 0) {
						continue;
					}
					urlQueue.put(url);
				}
				urlQueue.put("");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		private String getUrl() {
			return null;
		}
	}
	
	class SpiderThread implements Runnable {
		
		@Override
		public void run() {
			try {
				while (true) {
					String url = urlQueue.take();
					if (url.length() == 0) {
						//get empty single put back and stop thread
						//then the other thread can get the empty single
						urlQueue.put(url);
						break;
					}
					Html html = crawl(url);
					if (html == null) {
						// deal fail
						continue;
					}
					htmlQueue.put(html);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		private Html crawl(String url) {
			return null;
		}
	}
	
	class ParserThread implements Runnable {

		@Override
		public void run() {
			try {
				while (true) {
					Html take = htmlQueue.take();
					if (take.isEmpty()) {
						htmlQueue.put(take);
						break;
					}
					Meta meta = translate(take);
					metaQueue.put(meta);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		private Meta translate(Html take) {
		        //parse data
			return null;
		}
		
	}
	
	class WriteThread implements Runnable {

		@Override
		public void run() {
			try {
				while (true) {
					Meta take = metaQueue.take();
					if (take.isEmpty()) {
						metaQueue.put(take);
						break;
					}
					write(take);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		private void write(Meta take) {
			// write data
		}
		
	}
	
	class Html {
		
		private boolean empty;

		public boolean isEmpty() {
			return empty;
		}

		public void setEmpty(boolean empty) {
			this.empty = empty;
		}
	}
	
	class Meta {
		
		private boolean empty;

		public boolean isEmpty() {
			return empty;
		}

		public void setEmpty(boolean empty) {
			this.empty = empty;
		}
	}
}

这是一个简单的爬取和解析的简单爬虫，其中主要分：一、取数据，二、爬取数据，三、解析数据，四、写数据到硬盘网络

首先我会分析各部分所耗资源的点多线程

一、取数据：消耗资源的是磁盘，占用读取速度，这里不会是瓶颈。ide

二、爬取数据：消耗的资源是网络资源，相对于1来讲是很大的瓶颈，因此1只用起一个线程足矣。而这部分该起多少线程，固然是越多越好，可是还要考虑爬取站点的通畅性，适可的增长。this

三、解析数据：消耗的是CPU资源，哪这里我就会考虑CPU的核心数，通常来讲会起和CPU核心数相同的线程数。假如咱们多起两个线程，咱们能够想一想，若是线程数比CPU核心数多，必然会出现两个解析线程争抢一个CPU核心的资源。而这部分又是消耗CPU资源的，从而致使解析这块一定有线程处于阻塞状态，导致下降效率，因此在消耗CPU这块尽可能保证线程数超过CPU核心数目。url

四、写数据到硬盘：消耗的资源是硬盘，占用写速度，这里视爬取那块而定。但通常不会起太多线程，由于写入速度也是一个瓶颈，起太多不会对效率提升有多大影响。spa