多线程获取yahoo股票信息

首先给到需要获取和计算的股票，存入一个文本中，如stocks.txt

01 AAPL,2505
02 AMGN,3406
03 AMZN,9354
04 BAC,9839
05 BMY,5099
06 CAT,8463
07 C,1500
08 CMCSA,6144
09 CSCO,4589
10 CVX,9696
11 DIS,4804
12 DOW,3654
13 EMC,4835
14 FDX,4753
15 GD,3919
16 GE,7003
17 GOOG,6631
18 HAL,2593
19 HPQ,6157
20 IBM,1728
21 INTC,4053
22 JPM,1665
23 LMT,4402
24 MET,3712
25 MO,3764
26 MSFT,2813
27 NKE,6447
28 NSC,5537
29 ORCL,7136
30 PFE,659
31 RTN,5063
32 S,8219
33 SO,7175
34 TXN,1410
35 USB,3099
36 VZ,9826
37 WMT,6478

然后定义个抽象类，用于读取这个stocks.txt中存放的股票信息，并计算出股票的总值和读取花费的时间。代码如下：

01 public abstract class AbstractNAV {
02   public static Map<String, Integer> readTickers() throws IOException {
03     final BufferedReader reader = 
04       new BufferedReader(new FileReader("d:/stocks.txt"));
05      
06     final Map<String, Integer> stocks = new HashMap<String, Integer>();
07      
08     String stockInfo = null;
09     while((stockInfo = reader.readLine()) != null) {
10       final String[] stockInfoData = stockInfo.split(",");
11       final String stockTicker = stockInfoData[0];
12       final Integer quantity = Integer.valueOf(stockInfoData[1]);
13        
14       stocks.put(stockTicker, quantity); 
15     }
16      
17     return stocks;    
18   }
19     
20   public void timeAndComputeValue() 
21     throws ExecutionException, InterruptedException, IOException { 
22     final long start = System.nanoTime();
23      
24     final Map<String, Integer> stocks = readTickers();
25     final double nav = computeNetAssetValue(stocks);    
26      
27     final long end = System.nanoTime();
28  
29     final String value = new DecimalFormat("$##,##0.00").format(nav);
30     System.out.println("Your net asset value is " + value);
31     System.out.println("Time (seconds) taken " + (end - start)/1.0e9);
32   }
33  
34   public abstract double computeNetAssetValue(
35     final Map<String, Integer> stocks) 
36     throws ExecutionException, InterruptedException, IOException;
37 }

然后，我们用传统的单线程方式，依次去读取并计算股票，并打印总价和花费的时间，代码如下：

01 public class SequentialNAV extends AbstractNAV {
02   public double computeNetAssetValue(
03     final Map<String, Integer> stocks) throws IOException {
04     double netAssetValue = 0.0;
05     for(String ticker : stocks.keySet()) {
06       netAssetValue += stocks.get(ticker) * YahooFinance.getPrice(ticker);
07     }
08     return netAssetValue;   
09   } 
10     
11   public static void main(final String[] args) 
12     throws ExecutionException, IOException, InterruptedException { 
13     new SequentialNAV().timeAndComputeValue();
14   }
15 }

由于网络问题，我这里运行之后，得到的结果是：

1 Your net asset value is $18,317,338.21
2 Time (seconds) taken 18.080151543

紧接着，我们用多线程方式，读取并计算，并打印总价和时间花费

01 public class ConcurrentNAV extends AbstractNAV {
02     public double computeNetAssetValue(final Map<String, Integer> stocks)
03             throws InterruptedException, ExecutionException {
04         final int numberOfCores = Runtime.getRuntime().availableProcessors();
05         final double blockingCoefficient = 0.9;
06         final int poolSize = (int)(numberOfCores / (1 - blockingCoefficient));
07  
08         System.out.println("Number of Cores available is " + numberOfCores);
09         System.out.println("Pool size is " + poolSize);
10         //Callable接口的实例，用于被另一个线程执行call()，并返回，无返回则抛出异常。
11         //它类似于Runnable接口，而Runnable 不会返回结果，并且无法抛出经过检查的异常。 
12         final List<Callable<Double>> partitions =
13                 new ArrayList<Callable<Double>>();
14         for(final String ticker : stocks.keySet()) {
15             partitions.add(new Callable<Double>() {
16                 public Double call() throws Exception {
17                     return stocks.get(ticker) * YahooFinance.getPrice(ticker);
18                 }
19             });
20         }
21          
22         //定义线程池
23         final ExecutorService executorPool =
24                 Executors.newFixedThreadPool(poolSize);
25         //Future接口的实例，通过get()方法，获取多线程下异步的计算结果。
26         //必要时，计算完成前可阻塞该方法，可通过cancel()取消计算，一旦计算完成，则无法取消。
27         final List<Future<Double>> valueOfStocks =
28                 executorPool.invokeAll(partitions, 10000, TimeUnit.SECONDS);
29  
30         double netAssetValue = 0.0;
31         for(final Future<Double> valueOfAStock : valueOfStocks)
32             netAssetValue += valueOfAStock.get();
33  
34         executorPool.shutdown();
35         return netAssetValue;
36     }
37  
38     public static void main(final String[] args)
39             throws ExecutionException, InterruptedException, IOException {
40         new ConcurrentNAV().timeAndComputeValue();
41     }
42 }

在跟上面同等的网络环境下，这段代码运行之后的结果为：

1 Number of Cores available is 4
2 Pool size is 40
3 Your net asset value is $18,317,338.21
4 Time (seconds) taken 0.715660335

多线程获取yahoo股票信息

时间： 2024-10-25 12:02:32

多线程获取yahoo股票信息的相关文章

多线程获取数据库数据

在开发中,如大量获取数据时,不但速度慢,而且影响效率,下面就给大家介绍下用多线程获取数据库数据: 1.首先新建一个获取实体列表的方法,如想获取数量或其他类型,需要另外编写方法,这里只是做简单的介绍: /// <summary> /// 根据SQL语句返回实体集合,这里不能返回IQueryable,否则在线程中会获取不到上下文对象 /// </summary> /// <typeparam name="T"></typeparam> ///

java 多线程 获取线程返回结果

我们在使用java多线程编写相关业务代码时,往往有这样一种情况,某个线程依赖于其他线程执行结果. 也就是说,我们需要在一个线程中获取另一个线程的信息.可以分为两种情况,一种是轮询,一种是回调,因为轮询效率很低,所以本文主要介绍回调方法. 回调的主要思想是:线程run方法执行结束时,主动通知main线程,在main线程中做相应处理.通知main线程可以通过调用main方法中的static方法实现. 假定以下场景: 两个线程读取两个不同文件,最后拼接两个文件内容输出. 1.以下是线程代码: 1 pa

ios 异步多线程 获取数据

简介 iOS有三种多线程编程的技术,分别是: (一)NSThread (二)Cocoa NSOperation (三)GCD(全称:Grand Central Dispatch) 这三种编程方式从上到下,抽象度层次是从低到高的,抽象度越高的使用越简单,也是Apple最推荐使用的. 三种方式的优缺点介绍: 1)NSThread: 优点:NSThread 比其他两个轻量级 缺点:需要自己管理线程的生命周期,线程同步.线程同步对数据的加锁会有一定的系统开销 NSThread实现的技术有下面三种: 一般

python 获取yahoo股票数据

import pandas as pd from pandas_datareader import data import datetime start = datetime.datetime(2016,1,1) end = datetime.date.today() apple = data.DataReader("AAPL", "yahoo", start, end) #type(apple) apple.head() Date         Open    

python3 多线程获取数据实例

import requestsimport jsonfrom retrying import retryfrom lxml import etreefrom queue import Queueimport threading class QiuShi: def __init__(self): # 定义三个队列 self.url_queue = Queue() self.html_queue = Queue() self.content_list_queue = Queue() self.hea

python多线程获取子线程任务返回值

今天想实现多线程更新资产信息,所以使用到了threading,但是我需要每个线程的返回值,这就需要我在threading.Thread的基础上进行封装 def auto_asset(node): ret = salt.remote_grains_execution_sigle(node) asset_info={} asset_info['os']= ret[node]['oscodename'] asset_info['kernelrelease']= ret[node]['kernelrel

python分别使用多线程和多进程获取所有股票实时数据

python分别使用多线程和多进程获取所有股票实时数据 前一天简单介绍了python怎样获取历史数据和实时分笔数据,那么如果要获取所有上市公司的实时分笔数据,应该怎么做呢? 肯定有人想的是,用一个列表存储所有上市公司的股票代号,然后无限循环获取不就得了吗? 现在深市和沪市的股票一共有3400多只,如果你真这样做的话,获取一次所有股票的实时数据需要十几二十秒的时间,甚至更多,而且非常容易因为等待超时而使程序挂掉,如果你的模型对实时数据的质量要求非常高,这肯定是不行的,即使不考虑数据质量,获取数据的

python通过多线程并获取返回值

以下是多线程获取返回值的一种实现方式 # -*-coding:utf-8-*- from time import ctime, sleep import threading import numpy as np import collections loops = ['广州', '北京'] t_list = ['01', '02', '03'] cldas_sum = collections.deque() class MyThread(threading.Thread): def __init

黑马程序员--Java基础学习笔记【序列化、多线程】

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 序列化流与反序列化流 ObjectOutputStream 对象输出流 writeObject(Object obj) 可对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中 ObjectInputStream对象输入流 readObject(Objectobj) 从源输入流中读取字节序列,反序列化为一个对象并返回 序列化:将数据分解成字节流,以便存储在文件中或在网络上传输