Skip to content

S
smallproject
Commit 89de8dda by mahaisong
Options

fix:打磨优化测试桌面程序\输出日志\并行化CPU线程数调用ES(大大缩减调用ES时间) 3万2千次，用时13分钟。

parent ac82097e
Showing with 1799 additions and 92 deletions
6.CsvCount_ES/CsvCount_ES/App.config
......@@ -23,8 +23,9 @@
</factoryAdapter>
</logging>
</common>
<appSettings>
</appSettings>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
</startup>
......
6.CsvCount_ES/CsvCount_ES/CsvCount_ES.csproj
......@@ -93,6 +93,15 @@
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="ResultModel\ResultItem.cs" />
<Compile Include="ThreadPoolDispatcher\SingleThreadRunner.cs" />
<Compile Include="ThreadPoolDispatcher\ThreadPool.ActionTFuncT\ThreadPool.ActionT.cs" />
<Compile Include="ThreadPoolDispatcher\ThreadPool.ActionTFuncT\ThreadPool.FuncT.cs" />
<Compile Include="ThreadPoolDispatcher\ThreadPool.cs" />
<Compile Include="ThreadPoolDispatcher\WorkItem\Impl\WorkItem.cs" />
<Compile Include="ThreadPoolDispatcher\WorkItem\Impl\WorkItemState.cs" />
<Compile Include="ThreadPoolDispatcher\WorkItem\Impl\WorkItemStateTypeless.cs" />
<Compile Include="ThreadPoolDispatcher\WorkItem\IWorkItemState.cs" />
<Compile Include="ThreadPoolDispatcher\WorkItem\IWorkItemStateTypeless.cs" />
<Compile Include="V1.cs" />
<EmbeddedResource Include="Form1.resx">
<DependentUpon>Form1.cs</DependentUpon>
......@@ -126,7 +135,9 @@
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<ItemGroup />
<ItemGroup>
<Content Include="ThreadPoolDispatcher\z_线程池框架说明.txt" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
......
6.CsvCount_ES/CsvCount_ES/Form1.Designer.cs
......@@ -41,6 +41,14 @@
this.label4 = new System.Windows.Forms.Label();
this.label5 = new System.Windows.Forms.Label();
this.textBox_block = new System.Windows.Forms.TextBox();
this.label6 = new System.Windows.Forms.Label();
this.label7 = new System.Windows.Forms.Label();
this.textBox_CPU = new System.Windows.Forms.TextBox();
this.label8 = new System.Windows.Forms.Label();
this.label9 = new System.Windows.Forms.Label();
this.textBox_output = new System.Windows.Forms.TextBox();
this.label10 = new System.Windows.Forms.Label();
this.label11 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// openFileDialog1
......@@ -51,7 +59,7 @@
//
this.button1.Location = new System.Drawing.Point(503, 34);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.Size = new System.Drawing.Size(99, 23);
this.button1.TabIndex = 0;
this.button1.Text = "1.选择文件";
this.button1.UseVisualStyleBackColor = true;
......@@ -76,7 +84,7 @@
// button2
//
this.button2.Enabled = false;
this.button2.Location = new System.Drawing.Point(503, 77);
this.button2.Location = new System.Drawing.Point(503, 177);
this.button2.Name = "button2";
this.button2.Size = new System.Drawing.Size(99, 27);
this.button2.TabIndex = 3;
......@@ -87,26 +95,31 @@
// label2
//
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(6, 121);
this.label2.Location = new System.Drawing.Point(6, 219);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(58, 13);
this.label2.Size = new System.Drawing.Size(82, 13);
this.label2.TabIndex = 5;
this.label2.Text = "执行日志:";
this.label2.Text = "执行过程日志:";
//
// listBox1
//
this.listBox1.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawVariable;
this.listBox1.Enabled = false;
this.listBox1.Font = new System.Drawing.Font("宋体", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.listBox1.FormattingEnabled = true;
this.listBox1.Location = new System.Drawing.Point(113, 121);
this.listBox1.ItemHeight = 12;
this.listBox1.Location = new System.Drawing.Point(113, 219);
this.listBox1.Name = "listBox1";
this.listBox1.Size = new System.Drawing.Size(431, 160);
this.listBox1.Size = new System.Drawing.Size(489, 160);
this.listBox1.TabIndex = 8;
this.listBox1.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.ListBoxGroupRange_DrawItem);
this.listBox1.MeasureItem += new System.Windows.Forms.MeasureItemEventHandler(this.ListBoxGroupRange_MeasureItem);
this.listBox1.SelectedIndexChanged += new System.EventHandler(this.listBox1_SelectedIndexChanged);
//
// label3
//
this.label3.AutoSize = true;
this.label3.Location = new System.Drawing.Point(3, 331);
this.label3.Location = new System.Drawing.Point(3, 392);
this.label3.Name = "label3";
this.label3.Size = new System.Drawing.Size(106, 13);
this.label3.TabIndex = 9;
......@@ -115,7 +128,7 @@
// textBox_path
//
this.textBox_path.Enabled = false;
this.textBox_path.Location = new System.Drawing.Point(113, 331);
this.textBox_path.Location = new System.Drawing.Point(113, 392);
this.textBox_path.Name = "textBox_path";
this.textBox_path.Size = new System.Drawing.Size(517, 20);
this.textBox_path.TabIndex = 10;
......@@ -123,7 +136,7 @@
// label_wait
//
this.label_wait.AutoSize = true;
this.label_wait.Location = new System.Drawing.Point(232, 77);
this.label_wait.Location = new System.Drawing.Point(110, 191);
this.label_wait.Name = "label_wait";
this.label_wait.Size = new System.Drawing.Size(0, 13);
this.label_wait.TabIndex = 11;
......@@ -131,33 +144,112 @@
// label4
//
this.label4.AutoSize = true;
this.label4.Location = new System.Drawing.Point(6, 371);
this.label4.Location = new System.Drawing.Point(6, 432);
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(381, 13);
this.label4.Size = new System.Drawing.Size(402, 13);
this.label4.TabIndex = 12;
this.label4.Text = "参考：1.800W条记录不查ES，7秒统计次数（400M，分块大小10240B）";
this.label4.Text = "参考1：800W条记录不查ES，统计次数用时7秒（400M，分块大小10240B）";
//
// label5
//
this.label5.AutoSize = true;
this.label5.Location = new System.Drawing.Point(3, 77);
this.label5.Name = "label5";
this.label5.Size = new System.Drawing.Size(104, 13);
this.label5.Size = new System.Drawing.Size(89, 13);
this.label5.TabIndex = 13;
this.label5.Text = "分块并行读取(B)：";
this.label5.Text = "1.读取文件(B)：";
//
// textBox_block
//
this.textBox_block.Location = new System.Drawing.Point(113, 77);
this.textBox_block.Location = new System.Drawing.Point(114, 74);
this.textBox_block.Name = "textBox_block";
this.textBox_block.Size = new System.Drawing.Size(119, 20);
this.textBox_block.TabIndex = 14;
this.textBox_block.Text = "10240";
//
// label6
//
this.label6.AutoSize = true;
this.label6.Location = new System.Drawing.Point(3, 470);
this.label6.Name = "label6";
this.label6.Size = new System.Drawing.Size(404, 13);
this.label6.TabIndex = 15;
this.label6.Text = "参考2：3W2千条并行调用ES，调用完成用时13分钟（单核30，总线程120）";
//
// label7
//
this.label7.AutoSize = true;
this.label7.Location = new System.Drawing.Point(3, 506);
this.label7.Name = "label7";
this.label7.Size = new System.Drawing.Size(304, 13);
this.label7.TabIndex = 16;
this.label7.Text = "参考3：3W2千条写入JSON文件，用时1分钟（1个文件）";
//
// textBox_CPU
//
this.textBox_CPU.Location = new System.Drawing.Point(114, 110);
this.textBox_CPU.Name = "textBox_CPU";
this.textBox_CPU.Size = new System.Drawing.Size(119, 20);
this.textBox_CPU.TabIndex = 18;
this.textBox_CPU.Text = "30";
//
// label8
//
this.label8.AutoSize = true;
this.label8.Location = new System.Drawing.Point(6, 113);
this.label8.Name = "label8";
this.label8.Size = new System.Drawing.Size(66, 13);
this.label8.TabIndex = 17;
this.label8.Text = "2.调用ES：";
//
// label9
//
this.label9.AutoSize = true;
this.label9.Location = new System.Drawing.Point(3, 154);
this.label9.Name = "label9";
this.label9.Size = new System.Drawing.Size(88, 13);
this.label9.TabIndex = 19;
this.label9.Text = "3.输出文件数：";
//
// textBox_output
//
this.textBox_output.Location = new System.Drawing.Point(114, 154);
this.textBox_output.Name = "textBox_output";
this.textBox_output.Size = new System.Drawing.Size(119, 20);
this.textBox_output.TabIndex = 20;
this.textBox_output.Text = "1";
//
// label10
//
this.label10.AutoSize = true;
this.label10.Location = new System.Drawing.Point(239, 116);
this.label10.Name = "label10";
this.label10.Size = new System.Drawing.Size(113, 13);
this.label10.TabIndex = 21;
this.label10.Text = "单核CPU利用线程数";
//
// label11
//
this.label11.AutoSize = true;
this.label11.Location = new System.Drawing.Point(239, 77);
this.label11.Name = "label11";
this.label11.Size = new System.Drawing.Size(68, 13);
this.label11.TabIndex = 22;
this.label11.Text = "分块大小(B)";
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(644, 408);
this.ClientSize = new System.Drawing.Size(723, 541);
this.Controls.Add(this.label11);
this.Controls.Add(this.label10);
this.Controls.Add(this.textBox_output);
this.Controls.Add(this.label9);
this.Controls.Add(this.textBox_CPU);
this.Controls.Add(this.label8);
this.Controls.Add(this.label7);
this.Controls.Add(this.label6);
this.Controls.Add(this.textBox_block);
this.Controls.Add(this.label5);
this.Controls.Add(this.label4);
......@@ -172,7 +264,6 @@
this.Controls.Add(this.button1);
this.Name = "Form1";
this.Text = "Form1";
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
this.PerformLayout();
......@@ -193,6 +284,14 @@
private System.Windows.Forms.Label label4;
private System.Windows.Forms.Label label5;
private System.Windows.Forms.TextBox textBox_block;
private System.Windows.Forms.Label label6;
private System.Windows.Forms.Label label7;
private System.Windows.Forms.TextBox textBox_CPU;
private System.Windows.Forms.Label label8;
private System.Windows.Forms.Label label9;
private System.Windows.Forms.TextBox textBox_output;
private System.Windows.Forms.Label label10;
private System.Windows.Forms.Label label11;
}
}
6.CsvCount_ES/CsvCount_ES/Form1.cs
......@@ -5,6 +5,7 @@ using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.Drawing;
......@@ -20,12 +21,28 @@ namespace CsvCount_ES
{
public partial class Form1 : Form
{
#region 初始化、变量
//key:newsid字段，也是itemid字段,value:int-次数累计
private ConcurrentDictionary<string, int> totalCountDic = new ConcurrentDictionary<string, int>();
//链式结构 key: Int64 累加(对应分块的块号)， value：这一块的ListModel的第一行和最后一行的string内容
private ConcurrentDictionary<Int64, ListModel> listModelDic = new ConcurrentDictionary<Int64, ListModel>();
//放在队列里面慢慢输出
private ConcurrentQueue<ResultItem> ResultQueue = new ConcurrentQueue<ResultItem>();
/// <summary>
/// 消费：弹出后放入线程池中消费
/// </summary>
/// <remarks></remarks>
private static ThreadPool _threadPool;
private Stopwatch readfilesw = new Stopwatch();//读取并处理文件的执行时间。
private Stopwatch essw = new Stopwatch();//统计全部的es调用执行时间。
private static Int64 sn = 0;
//警告 在 32 位 Intel 计算机上分配 64 位值不是原子操作；即该操作不是线程安全的。这意味着，如果两个人同时将一个值分配给一个静态 Int64 字段，则该字段的最终值是无法预测的。
......@@ -38,47 +55,45 @@ namespace CsvCount_ES
//新建线程，线程数加一
return Interlocked.Increment(ref sn);
}
int count = 0;
int errorCount = 0;
int errorEsCount = 0;
string filePath = "";
public Form1()
{
InitializeComponent();
this.listBox1.HorizontalScrollbar = true;
textBox_block.Text = "10240";
this.openFileDialog1.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
this.openFileDialog1.Filter = "数据文件|*.csv";
}
#endregion
private void button1_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
textBox1.Text = openFileDialog1.FileName;
button2.Enabled = true;
listBox1.Items.Clear();
count = 0;
errorCount = 0;
errorEsCount = 0;
filePath = "";
textBox_path.Text = "";
label_wait.Text = "尚未开始执行！";
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
sn = 0;
while (ResultQueue.Count > 0)
{
ResultItem ritem;
ResultQueue.TryDequeue(out ritem);
}
listModelDic.Clear();
totalCountDic.Clear();
ListControl ls = (ListControl)sender;
MessageBox.Show(ls.Text);
label_wait.Text = "尚未开始执行！";
}
}
private void button2_Click(object sender, EventArgs e)
......@@ -92,26 +107,43 @@ namespace CsvCount_ES
//UTF-8编码中，一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。 本次文件中主要是英文和数字，没有中文。所以要多少字就配多大块。
//50千字节(kb)=51200字节(b)
//200千字节(kb)=204800字节(b)
if (String.IsNullOrWhiteSpace(textBox_block.Text) || !Int64.TryParse(textBox_block.Text, out length))
if (String.IsNullOrWhiteSpace(textBox_block.Text) || !Int64.TryParse(textBox_block.Text, out length) || length < 1)
{
MessageBox.Show("请正确输入分块并行读取(B)");
MessageBox.Show("请正确输入'分块大小'(B)");
return;
}
int tempint = 0;
if (String.IsNullOrWhiteSpace(textBox_CPU.Text) || !int.TryParse(textBox_CPU.Text, out tempint) || tempint < 1)
{
MessageBox.Show("请正确输入'单核CPU利用线程数'");
return;
}
if (String.IsNullOrWhiteSpace(textBox_output.Text) || !int.TryParse(textBox_output.Text, out tempint) || tempint < 1)
{
label_wait.Text = "正在执行分析,请耐心等待........！";
MessageBox.Show("请正确输入'输出文件数'");
return;
}
this.listBox1.Items.Add("开始执行：" + textBox1.Text.ToString());
this.listBox1.Items.Add("1.1开始： 读取并统计行数。");
label_wait.Text = "请勿关闭,正在执行分析,耐心等待........！";
button1.Enabled = false;
textBox1.Enabled = false;
button2.Enabled = false;
textBox_block.Enabled = false;
textBox_CPU.Enabled = false;
textBox_output.Enabled = false;
listBox1.Enabled = true;
filePath = Environment.CurrentDirectory + "\\OutPut\\" + ConvertDataTimeToLong(DateTime.Now).ToString() + ".json";
Application.DoEvents();
#region 执行内存映射方案
......@@ -128,8 +160,10 @@ namespace CsvCount_ES
Int64 portion = (Int64)Math.Ceiling(size * 1.0 / length); //分成多少块
this.listBox1.Items.Add("1.2初始化分块：单块" + length + "B，文件共分为" + portion + "块。");
this.listBox1.Items.Add("1.3处理中：并行分块处理此文件…………");
string fp2 = @filepath;
readfilesw.Start();
//统一使用总文件大小的内存隐射对象
using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(fp2, FileMode.Open, "mapname", size))
{
......@@ -145,11 +179,6 @@ namespace CsvCount_ES
{
List<string> list = new List<string>();
////每隔100是1行
//for (int i = 0; i < fileSize; i += length)
//{
//Int64 listkey = ADD();
byte[] byteArray = new byte[length];
......@@ -201,6 +230,8 @@ namespace CsvCount_ES
try
{
ADD();
string key = k[j].Split(',')[1].Replace("\0", string.Empty).Replace("\r", string.Empty).Trim();
totalCountDic.AddOrUpdate(key, 1, (skey, scount) => { return scount = scount + 1; });
......@@ -238,9 +269,13 @@ namespace CsvCount_ES
try
{
string key = listModelDic[1].End;
string key = listModelDic[0].End;
if (!String.IsNullOrWhiteSpace(key))
totalCountDic.AddOrUpdate(listModelDic[1].End.Split(',')[1], 0, (skey, scount) => { return scount = scount + 1; });
{
ADD();
totalCountDic.AddOrUpdate(listModelDic[0].End.Split(',')[1], 0, (skey, scount) => { return scount = scount + 1; });
}
}
catch (Exception ext)
{
......@@ -270,7 +305,7 @@ namespace CsvCount_ES
}
ADD();
string key = str.Split(',')[1];
totalCountDic.AddOrUpdate(key, 0, (skey, scount) => { return scount = scount + 1; });
......@@ -288,6 +323,12 @@ namespace CsvCount_ES
}
}
readfilesw.Stop();
this.listBox1.Items.Add("1.4处理完毕：");
this.listBox1.Items.Add(" 处理行数：共" + sn + "行！与文件行数相同,标题列1行不算。");
this.listBox1.Items.Add(" 处理完成用时：" + readfilesw.ElapsedMilliseconds + "毫秒！");
this.listBox1.Items.Add(" 统计行数后：共" + totalCountDic.Count() + "行！");
#endregion
}
catch (IOException ex)
......@@ -336,25 +377,210 @@ namespace CsvCount_ES
{
//1.生成统计后ConcurrentDictionary
button2_Click(null, null);
this.listBox1.Items.Add("2.1开始： 并行调用ES，返回内容。");
//2.初始化4个线程。对应市场常用电脑配置。
int ThreadCount = 4;
int CPU = 2;//如果没有使用。也就是创建了1个8个线程的线程池而已。
int tempint = 4;
if (String.IsNullOrWhiteSpace(textBox_CPU.Text) || !int.TryParse(textBox_CPU.Text, out CPU))
{
}
ThreadCount = CPU * Environment.ProcessorCount;
try
{
using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate))
//线程数量、线程名称
_threadPool = new ThreadPool(ThreadCount, "taikor");
}
catch (Exception ex)
{
using (StreamWriter sw = new StreamWriter(fs))
// throw;
}
this.listBox1.Items.Add("2.2初始化线程数：");
this.listBox1.Items.Add(" 共" + ThreadCount + "个线程并读取执行！");
this.listBox1.Items.Add(" CPU单核心并行读取ES线程数：" + CPU + "个线程;CPU核心数：" + Environment.ProcessorCount);
this.listBox1.Items.Add("2.3处理中：并行调用ES………………注意本机CPU，适当增减单个CPU线程数");
//全部入线程池队列。
//totalCountDic去重了。所以必须等待去重完成后再for。
foreach (var temp_item in totalCountDic)
{
sw.Write("[");
sw.Close();
//入队列，工作函数和（函数的参数）数组都传参，回调函数为空。
_threadPool.EnqueueWorkItem(ES_Complete, temp_item);
}
essw.Start();
//try
//{
// using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate))
// {
// using (StreamWriter sw = new StreamWriter(fs))
// {
// sw.Write("[");
// sw.Close();
// }
// }
// //2.循环取得item
// foreach (var temp_item in totalCountDic)
// {
// try
// {
// Item item_obj = ESItemAccess.SearchByItemID(temp_item.Key);
// ResultItem result = new ResultItem();
// result.ClickCount = temp_item.Value;
// if (item_obj != null)
// {
// #region 能从ES中查找到值
// result.ItemID = item_obj.ItemID;
// result.Url = item_obj.Url;
// result.Url = item_obj.Url;
// result.CleanTitle = item_obj.CleanTitle;
// result.CleanText = item_obj.CleanText;
// result.PubDate = item_obj.PubDate == null ? "" : item_obj.PubDate.ToString("yyyy-MM-dd HH:mm:ss.fff");
// result.MediaName = item_obj.MediaName;
// result.DuplicationID = item_obj.DuplicationID;
// //赋值 ResultItemAnalyzeData
// ResultItemAnalyzeData newdata = new ResultItemAnalyzeData();
// foreach (ItemAnalyzeData adata in item_obj.AnalyzeData)
// {
// if ((!String.IsNullOrWhiteSpace(adata.IssueID)) &&
// (adata.IssueID.Equals("Common") || adata.IssueID.Equals("Reader")))
// {
// //本次有值
// if (null != adata.StockIDs)
// {
// //内容不需叠加
// if (null == newdata.StockIDs)
// {
// newdata.StockIDs = adata.StockIDs;
// }
// //else
// //{
// // //内容需叠加
// // newdata.StockIDs = newdata.StockIDs.Union(adata.StockIDs).ToArray<string>(); //剔除重复项
// //}
// }
// if (null != adata.MarketIDs)
// {
// if (null == newdata.MarketIDs)
// {
// newdata.MarketIDs = adata.MarketIDs;
// }
// //else
// //{
// // newdata.MarketIDs = newdata.MarketIDs.Union(adata.MarketIDs).ToArray<string>(); //剔除重复项
// //}
// }
// if (null != adata.BlockIDs)
// {
// //内容不需叠加
// if (null == newdata.BlockIDs)
// {
// newdata.BlockIDs = adata.BlockIDs;
// }
// //else
// //{
// // //内容需叠加
// // newdata.BlockIDs = newdata.BlockIDs.Union(adata.BlockIDs).ToArray<string>(); //剔除重复项
// //}
// }
// if (null != adata.IG)
// {
// if (null == newdata.IG)
// {
// newdata.IG = adata.IG;
// }
// }
// }
// }//end for
// result.AnalyzeData = newdata;
// #endregion
// }
// //将result结果放入到集合中。统一转为json字符串，写入文件。
// string returnstr = JsonConvert.SerializeObject(result) + ",";
// using (FileStream fs = new FileStream(filePath, FileMode.Append))
// {
// using (StreamWriter sw = new StreamWriter(fs))
// {
// sw.Write(returnstr);
// sw.Flush();
// sw.Close();
// }
// }
// }
// catch (Exception ex)
// {
// MessageBox.Show(ex.ToString());
// }
// }
// using (FileStream fs = new FileStream(filePath, FileMode.Append))
// {
// using (StreamWriter sw = new StreamWriter(fs))
// {
// sw.Write("]");
// sw.Flush();
// sw.Close();
// }
// }
//}
//catch (Exception ext)
//{
// MessageBox.Show(ext.ToString());
//}
#region 执行完成
#endregion
}
//2.循环取得item
foreach (var temp_item in totalCountDic)
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="CountItem"></param>
private void ES_Complete(KeyValuePair<string, int> CountItem)
{
try
{
Item item_obj = ESItemAccess.SearchByItemID(temp_item.Key);
Item item_obj = ESItemAccess.SearchByItemID(CountItem.Key);
ResultItem result = new ResultItem();
result.ClickCount = temp_item.Value;
//如果为空，也要返回itemid 和 点击次数。
result.ItemID = CountItem.Key;
result.ClickCount = CountItem.Value;
if (item_obj != null)
{
#region 能从ES中查找到值
......@@ -439,60 +665,96 @@ namespace CsvCount_ES
#endregion
}
//将result结果放入到集合中。统一转为json字符串，写入文件。
else
{
//找不到ES的数量
Interlocked.Increment(ref errorEsCount);
string returnstr = JsonConvert.SerializeObject(result) + ",";
}
//将结果写入到队列中
ResultQueue.Enqueue(result);
using (FileStream fs = new FileStream(filePath, FileMode.Append))
{
using (StreamWriter sw = new StreamWriter(fs))
//totalCountDic已经去重了。所以可以count相等。
if (ResultQueue.Count == totalCountDic.Count)
{
sw.Write(returnstr);
sw.Flush();
sw.Close();
}
}
}
catch (Exception ex)
essw.Stop();
this.Invoke(new MethodInvoker(() =>
{
this.listBox1.Items.Add("2.4处理完毕：");
this.listBox1.Items.Add(" ES全部处理完成用时：" + essw.ElapsedMilliseconds + "毫秒！");
this.listBox1.Items.Add(" ES中找到的条数有：" + (totalCountDic.Count() - errorEsCount) + "条");
this.listBox1.Items.Add(" ES中找不到的条数有：" + errorEsCount + "条");
this.listBox1.Items.Add("3.1开始：写入JSON文件：");
this.listBox1.Items.Add("3.2初始化文件数量： "+ textBox_output.Text + "个。");
MessageBox.Show(ex.ToString());
}
));
//将result结果放入到集合中。统一转为json字符串，写入文件。
//string returnstr = JsonConvert.SerializeObject(result) + ",";
//using (FileStream fs = new FileStream(filePath, FileMode.Append))
//{
// using (StreamWriter sw = new StreamWriter(fs))
// {
// sw.Write(returnstr);
// sw.Flush();
// sw.Close();
// }
//}
errorCount = 0;
while (ResultQueue.Count > 0)
{
ResultItem ritem;
ResultQueue.TryDequeue(out ritem);
}
listModelDic.Clear();
totalCountDic.Clear();
using (FileStream fs = new FileStream(filePath, FileMode.Append))
this.Invoke(new MethodInvoker(() =>
{
using (StreamWriter sw = new StreamWriter(fs))
this.listBox1.Items.Add("完毕：程序执行完成。");
this.label_wait.Text = "此文件已经执行完毕！可以继续选择其他文件！";
MessageBox.Show("此文件已经执行完毕！可以继续选择其他文件！");
foreach (var item in this.listBox1.Items)
{
sw.Write("]");
sw.Flush();
sw.Close();
LogService.WriteInfo(item.ToString());
}
this.textBox_path.Text = filePath;
this.textBox1.Enabled = true;
this.button1.Enabled = true;
this.textBox_block.Enabled = true;
this.textBox_CPU.Enabled = true;
this.textBox_output.Enabled = true;
}));
}
}
catch (Exception ext)
catch (Exception ex)
{
MessageBox.Show(ext.ToString());
MessageBox.Show(ex.ToString());
}
#region 执行完成
label_wait.Text = "执行完毕！可以继续选择其他文件！";
this.textBox_path.Text = filePath;
//listBox1.Enabled = false;
textBox1.Enabled = true;
button1.Enabled = true;
textBox_block.Enabled = true;
errorCount = 0;
count = 0;
#endregion
}
public static long ConvertDataTimeToLong(DateTime dt)
{
DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
......@@ -502,9 +764,39 @@ namespace CsvCount_ES
return timeStamp;
}
private void Form1_Load(object sender, EventArgs e)
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
ListControl ls = (ListControl)sender;
MessageBox.Show(ls.Text);
}
private void GroupRangeTips_Load(object sender, EventArgs e)
{
this.listBox1.DrawMode = DrawMode.OwnerDrawVariable;
this.listBox1.DrawItem += new DrawItemEventHandler(ListBoxGroupRange_DrawItem);
}
//自绘Item，使其视觉效果更好
private void ListBoxGroupRange_DrawItem(object sender, DrawItemEventArgs e)
{
e.Graphics.FillRectangle(new SolidBrush(e.BackColor), e.Bounds);
if (e.Index >= 0)
{
StringFormat sStringFormat = new StringFormat();
sStringFormat.LineAlignment = StringAlignment.Center;
e.Graphics.DrawString(((ListBox)sender).Items[e.Index].ToString(), e.Font, new SolidBrush(e.ForeColor), e.Bounds, sStringFormat);
}
e.DrawFocusRectangle();
}
private void ListBoxGroupRange_MeasureItem(object sender, MeasureItemEventArgs e)
{
e.ItemHeight = e.ItemHeight + 12;
}
}
}
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/SingleThreadRunner.cs 0 → 100644

using System.Threading;
namespace CsvCount_ES
{
/// <summary>
/// 一个线程池、定义线程数、的框架。
/// </summary>
public class SingleThreadRunner
{
private bool signalClose;
private bool signalWork;
//工作项
private WorkItem currentWorkItem;
//自己项目的线程池类
public ThreadPool ThreadPool { get; set; }
public Thread Thread { get; set; }
/// <summary>
/// 实例化
/// </summary>
public SingleThreadRunner()
{
}
/// <summary>
/// 实例化
/// </summary>
public SingleThreadRunner(ThreadPool threadPool)
{
ThreadPool = threadPool;
}
/// <summary>
/// 处理和设置各种信号的工作。
/// </summary>
public void DoWork()
{
var spinWait = new SpinWait();
while (!signalClose)
{
if (signalWork)
{
while (currentWorkItem != null && !signalClose)
{
// 启动负载
currentWorkItem.Result = currentWorkItem.Delegate(currentWorkItem.DelegateInputParameters);
// 设置完成
currentWorkItem.IsCompleted = true;
//设置回调函数.
if (currentWorkItem.AsyncCallback != null)
{
currentWorkItem.AsyncCallback.Invoke(currentWorkItem.Result);
}
// 让下一个工作项出队列
if (ThreadPool.IsDisposeDoneWorkItemsAutomatically)
{
// 如果还有工作，则自动返回工作项以进行重用。
currentWorkItem = ThreadPool.DequeueWorkItemInternal(this, signalWork, currentWorkItem);
}
else
{
currentWorkItem = ThreadPool.DequeueWorkItemInternal(this, signalWork);
}
}
// 工作项没有更多的工作，也没有暂停。
signalWork = false;
}
else
{
spinWait.SpinOnce();
}
}
//线程关闭
signalClose = false;
}
/// <summary>
/// 立即开始执行。
/// </summary>
public void SignalWork(WorkItem workItemToProcess)
{
//等待主循环不繁忙，更改currentWorkItem工作项为新传递的参数。
var spinWait = new SpinWait();
while (signalWork)
{
spinWait.SpinOnce();
Thread.MemoryBarrier();
}
Interlocked.Exchange(ref currentWorkItem, workItemToProcess);
//InterlockedExChange来实现循环锁的功能，所谓循环锁，就是在线程1中如果要对变量进行操作，要先查看这个变量（或资源）有没有被其它线程用到，如果是，则一直循环，则到其它线程放弃对该变量（或资源）的控制。如果否，直接可以对该变量（或资源）进行操作。
signalWork = true;
Thread.MemoryBarrier();
}
/// <summary>
/// 工作项关闭信号。
/// </summary>
public void SignalShutDown()
{
signalClose = true;
}
/// <summary>
/// 工作项暂停信号。
/// </summary>
public void SignalPause()
{
Thread.MemoryBarrier();
signalWork = false;
Thread.MemoryBarrier();
}
/// <summary>
/// 工作项复位信号。
/// </summary>
public void SignalResume()
{
Thread.MemoryBarrier();
signalWork = true;
Thread.MemoryBarrier();
}
/// <summary>
/// 中止实例--终止线程。
/// </summary>
public void Abort()
{
Thread.Abort();
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/ThreadPool.ActionTFuncT/ThreadPool.ActionT.cs 0 → 100644

using System;
using System.Threading;
namespace CsvCount_ES
{
public partial class ThreadPool
{
//调用（IWorkItemState）的result属性触发锁，从而在函数执行之前阻塞当前线程。
//对返回对象立即调用Dispose，以自动重用每个对象后面的数据结构，以避免垃圾回收。
//在方法执行中可以根据IsCompleted验证属性。IsCompleted实际上触发了WaitOne（1）在（<see cref="ManualResetEvent" /> 内部）因此几乎立即返回。
/// <param name="workerFunction">The worker function.</param>
/// <param name="asyncCallback">异步回调处理函数</param>
/// <returns>
///返回（IWorkItemState）作为操作对象，该操作是排队、或者执行。
/// </returns>
public IWorkItemState EnqueueWorkItem(Action workerFunction, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke();
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <typeparam name="T1">类型</typeparam>
/// <param name="workerFunction">执行函数.</param>
/// <param name="arg1">参数1</param>
/// <param name="asyncCallback">异步回掉函数</param>
/// <returns>
/// 返回值：“工作项-状态结构"，该操作是排队、或者执行。
/// </returns>
public IWorkItemState EnqueueWorkItem<T1>(Action<T1> workerFunction, T1 arg1,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { arg1 };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke(arg1);
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState EnqueueWorkItem<T1, T2>(Action<T1, T2> workerFunction, T1 arg1, T2 arg2,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { arg1, arg2 };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke(arg1, arg2);
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState EnqueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> workerFunction, T1 arg1, T2 arg2, T3 arg3,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { arg1, arg2, arg3 };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke(arg1, arg2, arg3);
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <typeparam name="T4">The type of the 4.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="arg4">The arg4.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState EnqueueWorkItem<T1, T2, T3, T4>(Action<T1, T2, T3, T4> workerFunction, T1 arg1, T2 arg2,
T3 arg3,
T4 arg4, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { arg1, arg2, arg3, arg4 };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke(arg1, arg2, arg3, arg4);
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <typeparam name="T4">The type of the 4.</typeparam>
/// <typeparam name="T5">The type of the 5.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="arg4">The arg4.</param>
/// <param name="arg5">The arg5.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState EnqueueWorkItem<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> workerFunction, T1 arg1,
T2 arg2,
T3 arg3, T4 arg4, T5 arg5, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] { arg1, arg2, arg3, arg4, arg5 };
workItem.Delegate = delegateInputParameters =>
{
workerFunction.Invoke(arg1, arg2, arg3, arg4, arg5);
return null;
};
var workItemState = new WorkItemState(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/ThreadPool.ActionTFuncT/ThreadPool.FuncT.cs 0 → 100644

using System;
namespace CsvCount_ES
{
public partial class ThreadPool
{
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<V>(Func<V> workerFunction, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {};
workItem.Delegate = delegateInputParameters => { return workerFunction.Invoke(); };
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<T1, V>(Func<T1, V> workerFunction, T1 arg1,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {arg1};
workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1);
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<T1, T2, V>(Func<T1, T2, V> workerFunction, T1 arg1, T2 arg2,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {arg1, arg2};
workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1, arg2);
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<T1, T2, T3, V>(Func<T1, T2, T3, V> workerFunction, T1 arg1, T2 arg2,
T3 arg3,
CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {arg1, arg2, arg3};
workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1, arg2, arg3);
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <typeparam name="T4">The type of the 4.</typeparam>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="arg4">The arg4.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<T1, T2, T3, T4, V>(Func<T1, T2, T3, T4, V> workerFunction, T1 arg1,
T2 arg2,
T3 arg3, T4 arg4, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {arg1, arg2, arg3, arg4};
workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1, arg2, arg3, arg4);
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
/// <summary>
/// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or
/// queued, to be executed.
/// <para>Information on the returned struct... </para>
/// <para>
/// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function
/// has executed.
/// </para>
/// <para>
/// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to
/// avoid
/// garbage-collector-cycles.
/// </para>
/// <para>
/// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The
/// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a
/// ManualResetEvent internally thus returning almost instantly.
/// </para>
/// </summary>
/// <typeparam name="T1">The type of the 1.</typeparam>
/// <typeparam name="T2">The type of the 2.</typeparam>
/// <typeparam name="T3">The type of the 3.</typeparam>
/// <typeparam name="T4">The type of the 4.</typeparam>
/// <typeparam name="T5">The type of the 5.</typeparam>
/// <typeparam name="V">The type of the result.</typeparam>
/// <param name="workerFunction">The worker function.</param>
/// <param name="arg1">The arg1.</param>
/// <param name="arg2">The arg2.</param>
/// <param name="arg3">The arg3.</param>
/// <param name="arg4">The arg4.</param>
/// <param name="arg5">The arg5.</param>
/// <param name="asyncCallback">The async callback.</param>
/// <returns>
/// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed.
/// </returns>
public IWorkItemState<V> EnqueueWorkItem<T1, T2, T3, T4, T5, V>(Func<T1, T2, T3, T4, T5, V> workerFunction,
T1 arg1,
T2 arg2, T3 arg3, T4 arg4, T5 arg5, CallbackFunction asyncCallback = null)
{
var workItem = GetWorkItem(asyncCallback);
workItem.DelegateInputParameters = new object[] {arg1, arg2, arg3, arg4, arg5};
workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1, arg2, arg3, arg4, arg5);
var workItemState = new WorkItemState<V>(workItem.WorkItemStateTypeless);
EnqueueWorkItemInternal(workItem);
return workItemState;
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/ThreadPool.cs 0 → 100644

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
namespace CsvCount_ES
{
/// <summary>
///这个类实现了一个线程池。缓冲所有工作项。程序缓冲区只是在关闭时清理它们。
/// </summary>
public partial class ThreadPool
{
/// <summary>
/// 工作项有效负载的回调委托的形式。
/// </summary>
internal delegate object WorkItemCallback(object state);
/// <summary>
/// 当工作项完成时，应该调用的回调函数。
/// </summary>
public delegate void CallbackFunction(object o);
private bool isDisposeDoneWorkItemsAutomatically;
private readonly Queue<SingleThreadRunner> threads;
private readonly ConcurrentQueue<SingleThreadRunner> threadsIdle;
private int threadsWorking;
private readonly ConcurrentQueue<WorkItem> workItemQueue = new ConcurrentQueue<WorkItem>();
private readonly ConcurrentQueue<WorkItem> returnedWorkItems = new ConcurrentQueue<WorkItem>();
private bool shutDownSignaled;
private readonly object lockObjectShutDownSignaled = new object();
public int NumberOfThreads { get; }
/// <summary>
///获取或设置一个值，该值指示该实例是否将自动处理完成的工作项。
///注意:如果启用此选项，则在完成后立即调用每个工作项的dispose方法，从而销毁引用。
///当使用action - interface(不返回值)和<c> WaitForEveryWorkerIdle- method时，这显然只是一个可行的选项。
/// </summary>
/// <value>
/// <c>true</c> 如果这个实例是自动处理的工作项;否则, <c>false</c>.
/// </value>
public bool IsDisposeDoneWorkItemsAutomatically
{
get
{
Thread.MemoryBarrier();
return isDisposeDoneWorkItemsAutomatically;
}
set
{
isDisposeDoneWorkItemsAutomatically = value;
Thread.MemoryBarrier();
}
}
/// <summary>
/// 初始化线程池，
/// </summary>
/// <param name="numberOfThreads">指定线程数量</param>
/// <param name="threadsNamePrefix">线程名称前缀</param>
public ThreadPool(int numberOfThreads, string threadsNamePrefix)
{
NumberOfThreads = numberOfThreads;
threads = new Queue<SingleThreadRunner>();
threadsIdle = new ConcurrentQueue<SingleThreadRunner>();//闲置
// 分配线程
for (var i = 0; i < NumberOfThreads; i++)
{
//创建一个“线程框架”执行者
var singleThreadRunner = new SingleThreadRunner(this);
singleThreadRunner.Thread = new Thread(singleThreadRunner.DoWork);
singleThreadRunner.Thread.Name = threadsNamePrefix + (i + 1);//线程名
singleThreadRunner.Thread.IsBackground = true;
//入线程队列
threads.Enqueue(singleThreadRunner);
//入线程闲置队列
threadsIdle.Enqueue(singleThreadRunner);
singleThreadRunner.Thread.Start();
}
}
/// <summary>
/// 清空工作项队列
/// </summary>
public void ClearWorkItemQueue()
{
WorkItem wi;
while (workItemQueue.TryDequeue(out wi))
{}
}
/// <summary>
/// 仍需要执行的工作项数量
/// </summary>
/// <returns></returns>
public int NumberOfItemsLeft()
{
Thread.MemoryBarrier();
return workItemQueue.Count;
}
/// <summary>
/// 完成处理并返回的工作项数量。
/// </summary>
/// <returns></returns>
public int NumberOfItemsDone()
{
Thread.MemoryBarrier();
return returnedWorkItems.Count;
}
/// <summary>
/// 工作项入队列
/// </summary>
/// <param name="workItem">工作项.</param>
internal void EnqueueWorkItemInternal(WorkItem workItem)
{
// 找一个闲置的工作项
SingleThreadRunner singleThreadRunner;
if (threadsIdle.TryDequeue(out singleThreadRunner))
{
// 移交这个工作项
workItem.SingleThreadRunner = singleThreadRunner;
Interlocked.Increment(ref threadsWorking);
singleThreadRunner.SignalWork(workItem);
}
else
{
// 全忙、入队
workItemQueue.Enqueue(workItem);
}
}
/// <summary>
/// 工作项出队
/// </summary>
/// <param name="singleThreadRunner">The single thread runner.</param>
/// <param name="isGetNewOne">
/// if set to <c>true</c> [is get new one].
/// </param>
/// <param name="returnedWorkItem">The returned work item.</param>
/// <returns>
/// <see langword="true" />, if a work item has been
/// successfully dequeued. <see langword="false" /> otherwise.
/// </returns>
internal WorkItem DequeueWorkItemInternal(SingleThreadRunner singleThreadRunner, bool isGetNewOne,
WorkItem returnedWorkItem = null)
{
if (returnedWorkItem != null)
{
returnedWorkItems.Enqueue(returnedWorkItem);
}
if (!shutDownSignaled && isGetNewOne)
{
WorkItem workItem;
if (workItemQueue.TryDequeue(out workItem))
{
workItem.SingleThreadRunner = singleThreadRunner;
return workItem;
}
}
//工作项完成、闲置
Interlocked.Decrement(ref threadsWorking);
threadsIdle.Enqueue(singleThreadRunner);
return null;
}
private WorkItem GetWorkItem(CallbackFunction asyncCallback)
{
WorkItem workItem;
if (!returnedWorkItems.TryDequeue(out workItem))
{
workItem = new WorkItem();
workItem.WorkItemStateTypeless = new WorkItemStateTypeless(workItem);
}
workItem.SingleThreadRunner = null;
workItem.IsCompleted = false;
workItem.Result = null;
workItem.AsyncCallback = asyncCallback;
return workItem;
}
/// <summary>
/// 返回工作项
/// </summary>
/// <param name="returnedWorkItem">The returned work item.</param>
public void ReturnWorkItem(WorkItem returnedWorkItem)
{
returnedWorkItems.Enqueue(returnedWorkItem);
}
/// <summary>
/// 等待队列空--一般用法，是顺序执行此位置，来确保一个线程池执行完毕。如果是一直用的线程池或异步，则不需要执行此方法。
/// </summary>
public void WaitForEveryWorkerIdle()
{
//内旋，迫使CPU执行上下文切换,得到线程切换的目的
var spinWait = new SpinWait();
while (threadsWorking > 0)
{
Thread.MemoryBarrier();//内存屏障
spinWait.SpinOnce();
}
}
/// <summary>
/// 清除所有返回的工作项缓存，并通过dispose方法返回“被重用”的工作项。
/// </summary>
public void ClearWorkItemCache()
{
WorkItem w;
while(returnedWorkItems.TryDequeue(out w))
{}
}
/// <summary>
/// 中止所有活动线程
/// </summary>
public void ShutDown()
{
// 1.停止处理新的工作项……
lock (lockObjectShutDownSignaled)
{
shutDownSignaled = true;
}
// 向所有工作项发出关闭命令…
if (threads.Count > 0)
{
foreach (var thread in threads)
{
thread.SignalShutDown();
}
}
}
/// <summary>
/// 暂停所有活动线程。
/// </summary>
public void Sleep()
{
// 向所有工作项发出暂停命令的信号…
if (threads.Count > 0)
{
foreach (var thread in threads)
{
thread.SignalPause();
}
}
}
/// <summary>
/// 恢复所有活动线程。
/// </summary>
public void Wakeup()
{
// 向所有工作项发出恢复命令的信号…
if (threads.Count > 0)
{
foreach (var thread in threads)
{
thread.SignalResume();
}
}
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/WorkItem/IWorkItemState.cs 0 → 100644

using System;
namespace CsvCount_ES
{
/// <summary>
/// 这是一个线程工作项的接口。
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IWorkItemState<out T> : IDisposable
{
bool IsStopped { get; }
/// <summary>
///阻塞操作。得到Result。
/// </summary>
T Result { get; }
}
/// <summary>
/// 这是一个线程工作项的接口。
/// </summary>
public interface IWorkItemState : IDisposable
{
bool IsStopped { get; }
/// <summary>
/// 阻塞操作。 等待工作项完成。
/// </summary>
void Result();
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/WorkItem/IWorkItemStateTypeless.cs 0 → 100644

namespace CsvCount_ES
{
/// <summary>
/// work-item-state 无类型 接口.
/// </summary>
public interface IWorkItemStateTypeless : IWorkItemState<object>
{
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/WorkItem/Impl/WorkItem.cs 0 → 100644

using System.Threading;
namespace CsvCount_ES
{
/// <summary>
/// 一个工作的封装类。
/// </summary>
public class WorkItem
{
private object result;
public bool IsCompleted { get; set; }
/// <summary>
/// 回调函数
/// </summary>
internal ThreadPool.WorkItemCallback Delegate { get; set; }
public object DelegateInputParameters { get; set; }
/// <summary>
/// 工作状态
/// </summary>
public WorkItemStateTypeless WorkItemStateTypeless { get; set; }
/// <summary>
/// 线程类
/// </summary>
public SingleThreadRunner SingleThreadRunner { get; set; }
public object Result
{
get
{
// 自旋锁-工作完成
var spinWait = new SpinWait();
while (!IsCompleted)
{
spinWait.SpinOnce();
Thread.MemoryBarrier();
}
return result;
}
set { result = value; }
}
/// <summary>
/// 实例 <see cref="WorkItem" /> .
/// </summary>
internal WorkItem()
{
}
/// <summary>
/// 实例化 <see cref="WorkItem" /> .
/// </summary>
internal WorkItem(ThreadPool.WorkItemCallback functionDelegate, object delegateInputParameters)
{
Delegate = functionDelegate;
DelegateInputParameters = delegateInputParameters;
WorkItemStateTypeless = new WorkItemStateTypeless(this);
}
/// <summary>
/// 配置异步回调事件
/// </summary>
/// <value></value>
public ThreadPool.CallbackFunction AsyncCallback { get; set; }
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/WorkItem/Impl/WorkItemState.cs 0 → 100644

namespace CsvCount_ES
{
/// <summary>
/// 接口
/// </summary>
/// <typeparam name="T">T.</typeparam>
public struct WorkItemState<T> : IWorkItemState<T>
{
private bool disposed;
private readonly WorkItemStateTypeless workItemStateTypeless;
/// <summary>
/// 获取一个值，指示该实例是否完成。
/// </summary>
/// <value>
/// <c>true</c> <c>false</c>.
/// </value>
public bool IsStopped => workItemStateTypeless.IsStopped;
/// <summary>
/// result属性操作
/// </summary>
/// <value></value>
public T Result => (T) workItemStateTypeless.Result;
/// <summary>
/// 实例化<see cref="WorkItemState{TResult}" /> .
/// </summary>
/// <param name="workItemStateTypeless">工作单元状态</param>
public WorkItemState(WorkItemStateTypeless workItemStateTypeless)
{
this.workItemStateTypeless = workItemStateTypeless;
disposed = false;
}
/// <summary>
/// 释放
/// </summary>
/// <param name="disposing">
/// <c>true</c> 托管非托管 <c>false</c> 非托管
/// </param>
public void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
workItemStateTypeless.WorkItem.SingleThreadRunner.ThreadPool.ReturnWorkItem(
workItemStateTypeless.WorkItem);
}
disposed = true;
}
}
/// <summary>
/// 释放
/// </summary>
public void Dispose()
{
Dispose(true);
}
}
/// <summary>
/// 接口 <c>IWorkItemStateTypeless</c> .
/// </summary>
public struct WorkItemState : IWorkItemState
{
private bool disposed;
private readonly WorkItemStateTypeless workItemStateTypeless;
/// <summary>
/// 获取一个值，指示该实例是否完成。
/// </summary>
/// <value>
///
/// </value>
public bool IsStopped => workItemStateTypeless.IsStopped;
/// <summary>
/// 实例化 <see cref="WorkItemState{TResult}" /> .
/// </summary>
/// <param name="workItemStateTypeless">工作单元.</param>
public WorkItemState(WorkItemStateTypeless workItemStateTypeless)
{
this.workItemStateTypeless = workItemStateTypeless;
disposed = false;
}
/// <summary>
/// 阻塞操作等待工作项完成。销毁前使用。平时不使用。
/// </summary>
/// <value>.</value>
public void Result()
{
#pragma warning disable 168
var o = workItemStateTypeless.Result;
#pragma warning restore 168
}
/// <summary>
/// 释放
/// </summary>
/// <param name="disposing">
/// </param>
public void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
workItemStateTypeless.WorkItem.SingleThreadRunner.ThreadPool.ReturnWorkItem(
workItemStateTypeless.WorkItem);
}
disposed = true;
}
}
/// <summary>
/// 释放
/// </summary>
public void Dispose()
{
Dispose(true);
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/WorkItem/Impl/WorkItemStateTypeless.cs 0 → 100644

namespace CsvCount_ES
{
/// <summary>
/// 工作项的状态。
/// </summary>
public class WorkItemStateTypeless : IWorkItemStateTypeless
{
public WorkItem WorkItem { get; set; }
/// <summary>
/// 获取一个值，指示该实例是否完成。
/// </summary>
/// <value>
/// <c>true</c> <c>false</c>.
/// </value>
public bool IsStopped => WorkItem.IsCompleted;
/// <summary>
/// 得到result属性.
/// </summary>
/// <value></value>
public object Result => WorkItem.Result;
/// <summary>
/// 初始化类<see cref="WorkItemStateTypeless" /> 实例.
/// </summary>
/// <param name="workItem">工作单元</param>
public WorkItemStateTypeless(WorkItem workItem)
{
WorkItem = workItem;
}
/// <summary>
/// 释放
/// </summary>
public void Dispose()
{
}
}
}
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/ThreadPoolDispatcher/z_线程池框架说明.txt 0 → 100644


1.包含队列弹出的线程池管理类
WorkItem：某一个工作项的线程封装类。主要用来将 工作状态、线程、结果、是否完成、回调函数进行封装。
SingleThreadRunner: 某一个任务、对应的线程池的包装类。
对单个线程池和单个任务工作项进行包装。负责判断是否执行下一个、挂载回调函数等。
ThreadPool： 是总的"管理类"(负责管理多个不同的任务类型、同时执行)。
也是对入栈、出栈、总线程数、等待线程数满、下一个自动开线程执行、停止、销毁等操作的集合类。
概述：
多个线程公用同一个队列。
配置几个线程数，就有几个SingleThreadRunner对象。
多个SingleThreadRunner对象之间从---队列中争抢资源 由ThreadPool的队列控制管理。
----------------------------------等待线程空闲，由SingleThreadRunner对象自己管理。
--------说明1：
SingleThreadRunner
与
ThreadPool
相互引用关系。
ThreadPool管理多个SingleThreadRunner。
SingleThreadRunner在ThreadPool中传参， 内部调用ThreadPool的入、出、停止等方法。
--------说明2：
虽然类似Parallels，但和Parallels不同
解决问题：
你可以将不同的工作内容T放在一个单一的线程池。（而不是只有一个对象类型Parallels<T>,T只能是一个）,
作为一个程序核心不需要关心 每个功能分别需要多少参数和返回值。
你可以一次（把不同的）全部加进来，也可以每一个（不同的）作为一个工作项加入进来。
------说明3：
CPU核心数与线程数的关系：
AMD的CPU几核就是几核。
Intel的CPU ，它采用超线程技术，单核的通过超线程技术可以显示为双核，双核的显示为4核。
但是因为线程切换技术，所以一个CPU带10个、100个、1000个线程都不是问题。
所以CPU核心数*几，要根据性能来看。
///从唯一一个队列中读数据，最快的方式就是速度执行，但是存在卡住一个，其他的也没办法继续执行的问题。
///使用多线程的意义，在于不被全锁。在每个项目、每个线程意义上自旋。而不是整个全部锁。
///线程并不能提高速度，而是在执行某个耗时的功能时，在还可以做其它的事。多线程使你的程序在处理文件时不必显得已经卡死。
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/CsvCount_ES.exe.config
......@@ -23,8 +23,9 @@
</factoryAdapter>
</logging>
</common>
<appSettings>
</appSettings>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
</startup>
......
6.CsvCount_ES/CsvCount_ES/bin/Debug/CsvCount_ES.vshost.exe.config
......@@ -23,8 +23,9 @@
</factoryAdapter>
</logging>
</common>
<appSettings>
</appSettings>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
</startup>
......
6.CsvCount_ES/CsvCount_ES/bin/Debug/CsvCount_ES.vshost.exe.manifest 0 → 100644
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>
6.CsvCount_ES/CsvCount_ES/bin/Debug/Logs/err.log 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
6.CsvCount_ES/CsvCount_ES/bin/Debug/Logs/info.log 0 → 100644
2018-05-07 11:36:59,914 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:开始执行
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.1开始： 读取并统计行数。
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.2初始化分块：单块10240B，文件共分为44979块。
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.3处理中：并行分块处理此文件…………
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.4处理完毕：
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理行数：共8224718行！与文件行数相同,标题列1行不算。
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理完成用时：7419毫秒！
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 统计行数后：共32013行！
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.1开始： 并行调用ES，返回内容。
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.2初始化线程数：
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 共120个线程并读取执行！
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: CPU单核心并行读取ES线程数：30个线程;CPU核心数：4
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.3处理中：并行调用ES………………注意本机CPU，适当增减单个CPU线程数
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.4处理完毕：
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES全部处理完成用时：1726毫秒！
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找到的条数有：32013条
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找不到的条数有：0条
2018-05-07 11:36:59,921 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:完毕：程序执行完成。
2018-05-07 11:38:32,654 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:开始执行：C:\Users\admin\Desktop\hive_export.csv
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.1开始： 读取并统计行数。
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.2初始化分块：单块10240B，文件共分为44979块。
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.3处理中：并行分块处理此文件…………
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.4处理完毕：
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理行数：共8224718行！与文件行数相同,标题列1行不算。
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理完成用时：7666毫秒！
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 统计行数后：共32013行！
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.1开始： 并行调用ES，返回内容。
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.2初始化线程数：
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 共120个线程并读取执行！
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: CPU单核心并行读取ES线程数：30个线程;CPU核心数：4
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.3处理中：并行调用ES………………注意本机CPU，适当增减单个CPU线程数
2018-05-07 11:38:32,664 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.4处理完毕：
2018-05-07 11:38:32,665 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES全部处理完成用时：1806毫秒！
2018-05-07 11:38:32,665 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找到的条数有：32013条
2018-05-07 11:38:32,665 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找不到的条数有：0条
2018-05-07 11:38:32,665 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:完毕：程序执行完成。
2018-05-07 11:44:51,735 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:开始执行：C:\Users\admin\Desktop\2.csv
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.1开始： 读取并统计行数。
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.2初始化分块：单块10240B，文件共分为1块。
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.3处理中：并行分块处理此文件…………
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.4处理完毕：
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理行数：共42行！与文件行数相同,标题列1行不算。
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理完成用时：11122毫秒！
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 统计行数后：共32行！
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.1开始： 并行调用ES，返回内容。
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.2初始化线程数：
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 共120个线程并读取执行！
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: CPU单核心并行读取ES线程数：30个线程;CPU核心数：4
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.3处理中：并行调用ES………………注意本机CPU，适当增减单个CPU线程数
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.4处理完毕：
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES全部处理完成用时：19749毫秒！
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找到的条数有：16条
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找不到的条数有：16条
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:3.1开始：写入JSON文件：
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:3.2初始化文件数量： 1个。
2018-05-07 11:44:51,742 [9] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:完毕：程序执行完成。
2018-05-07 11:49:01,379 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:开始执行：C:\Users\admin\Desktop\2.csv
2018-05-07 11:49:01,385 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.1开始： 读取并统计行数。
2018-05-07 11:49:01,385 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.2初始化分块：单块10240B，文件共分为1块。
2018-05-07 11:49:01,385 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.3处理中：并行分块处理此文件…………
2018-05-07 11:49:01,385 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:1.4处理完毕：
2018-05-07 11:49:01,385 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理行数：共43行！与文件行数相同,标题列1行不算。
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 处理完成用时：46237毫秒！
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 统计行数后：共32行！
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.1开始： 并行调用ES，返回内容。
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.2初始化线程数：
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: 共120个线程并读取执行！
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: CPU单核心并行读取ES线程数：30个线程;CPU核心数：4
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.3处理中：并行调用ES………………注意本机CPU，适当增减单个CPU线程数
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:2.4处理完毕：
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES全部处理完成用时：2798毫秒！
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找到的条数有：16条
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1: ES中找不到的条数有：16条
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:3.1开始：写入JSON文件：
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:3.2初始化文件数量： 1个。
2018-05-07 11:49:01,386 [8] INFO loginfo - CsvCount_ES.Form1.<ES_Complete>b__15_1:完毕：程序执行完成。
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256558735103949.json 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256614902722752.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256616056496749.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256617984133345.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256619676703836.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256620966167381.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256630809096018.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256634189573228.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256637910024651.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
6.CsvCount_ES/CsvCount_ES/bin/Debug/OutPut/15256639747074928.json 0 → 100644
{"ItemID":"0a0a920c2c2fb5a5b50d37c15e931e58","ClickCount":90,"Url":"http://company.cnstock.com/company/scp_gsxw/201801/4174595.htm","CleanTitle":"铜铟镓硒(CIGS)获数百亿资本 加持","CleanText":"2018-01-11 08:19:34 来源：证券日报 作者：于南 不知是必然又或是偶然，近两年来，在一个并不为业界之外所熟识的光伏细分技术路线 铜铟镓硒（CIGS）上，突然涌现出了一批拥护者，而其中甚至汇聚了如中国神华集团、中建材这般有实力搅动中国光伏产业格局的 大玩家 。 尤其是在2017年底-2018年初，各方势力在铜铟镓硒的布局不约而同地传来了新消息，据《证券日报》记者整理，2017年12月份，中国建材集团旗下凯盛集团宣布其位于安徽蚌埠的300MW的铜铟镓硒薄膜组件产线正式投产；同样在2017年12月份，同煤集团、大同市经济发展投资有限公司和汉能集团也宣布其共同投资的第一条50MW产线开始投产；而紧随其后，2018年1月份，神华集团、上海电气、德国光伏设备制造商Manz AG共同出资建设的重庆神华薄膜太阳能项目宣布正式开工，据称该项目设计年产能为306MW。 一位接近重庆神华的不愿具名人士向《证券日报》记者表示，作为薄膜光伏技术路线之一的铜铟镓硒如此 受宠 ，主要得益于大致三点：光伏的应用正在趋向与建筑结合、与建材融合，而这是薄膜光伏技术柔性、美观性所奠定的基础；从光电转化效率来看，铜铟镓硒实验室水平已经达到22.6%，所以其未来具有更大的增长潜力；之所以铜铟镓硒能够从砷化镓、碲化镉等薄膜路线中暂时胜出，获得更多青睐，则源于其生产成本控制、工艺等相对更为成熟。 铜铟镓硒 赢得资本青睐 值得一提的是，尽管上述 大玩家 的入局，使得铜铟镓硒愈发受到关注。但在我国光伏产业中，更多的资本、产能目前仍然集中于多晶硅、单晶硅路线。而对铜铟镓硒等薄膜技术的未来，各方也仍各持己见。 不过，排除立场不同，较为客观的一种声音认为，单晶硅、多晶硅和薄膜在应用上各具优劣。比如从地面电站建设角度来看，在相等的装机容量要求下，单晶硅、多晶硅不需要更多的土地。但由于薄膜电池，特别是铜铟镓硒电池具有更好的弱光性（光照不足时，仍可发电）、温度不敏感性（对温度的变化不敏感，温度提高时，电池效能下降较小）。所以，在实际发电量上，薄膜优势则更为突出。 早在2013年时，中组部 千人计划 国家特聘专家、时任北京低碳清洁能源研究所太阳能中心主任的陈颉博士曾向《证券日报》记者透露过他在意大利获得的实验数据：在单晶硅的电池效率为18%、非晶硅和铜铟镓硒（均属薄膜类）分别为7%、12.5%的基础上，进行同环境、同规模，为期一年的实验所得数据显示，单晶硅年发电为1.05度/瓦、非晶硅1.21度/瓦、铜铟镓硒则为1.37度/瓦。 这意味着，在弱光性、温度不敏感性的作用下，薄膜电池能够获得了更高的发电量，而其中，铜铟镓硒尤为突出。 除了应用上可能存在的上述优势外，包括铜铟镓硒在内的薄膜技术的崛起，也离不开政府的推动。据《证券日报》记者了解，在德国工业年鉴上可以查到这样一组数据：在2009年至2013年间，德国政府有超过60%财政资助是针对薄膜电池的，更有超过70%的研究经费集中于薄膜光伏。 此外，陈颉曾向记者介绍道， 在德国，所有的薄膜光伏企业都享有电费补贴，但晶硅类企业却不享受。而德国政府自2011年9月恢复了对效率在11.6%以上的薄膜硅太阳能电池、效率在13.8%以上的铜铟镓硒太阳电池和效率在15%以上的碲化镉薄膜太阳能电池实施银行贷款补贴。 一场围绕铜铟镓硒 展开的竞争将拉开序幕 不论如何，种种因素促使薄膜，尤其是铜铟镓硒在若干年后于神州大地上赢得了数百亿元资金的青睐。据《证券日报》记者粗略整理，仅上述提及几个项目投资总额就已达到200亿元，其中中建材安徽蚌埠项目计划投资14.3亿欧元，约合人民币111亿元；而重庆神华项目总投资则将达到75亿元。可想而知，一场围绕铜铟镓硒的 竞争 ，将在中国拉开序幕。 那么，上文提及的 大玩家 们，目前都处在怎样的竞争格局之中呢？ 从技术角度来看，据了解，凯盛科技旗下德国Avancis公司生产的CIGS（玻璃基）薄膜太阳能全尺寸冠军组件，有效面积光电转换效率达到了16.4%；而与神华合作的德国Manz，其CIGS薄膜太阳能芯片的量产转换效率也达到了16%。 而作为中国发展薄膜太阳能技术的 鼻祖 ，公开的数据显示，汉能Solibro玻璃基CIGS薄膜太阳能量产冠军组件效率达到16.97%（有效面积17.92%），为共蒸法CIGS组件量产世界纪录；GSE柔性CIGS薄膜太阳能芯片研发效率18.7%，量产冠军组件效率达到16.2%；其MiaSol 柔性CIGS薄膜太阳能芯片当前的研发效率已达到19.4%，量产冠军组件效率也达到了18%，为目前全球溅射法CIGS柔性组件最高效率。 从目前来看，在足以影响产业格局的几家中，神华、中建材发展铜铟镓硒都是采用玻璃基的，这点上无形中使其丧失了薄膜太阳能的 柔性 优势（更好地与建筑、汽车等结合。） 一位业内人士向《证券日报》记者表示， 相比之下，汉能在铜铟镓硒上的技术储备更为全面，尤其是在他的GSE和MiaSol 柔性薄膜上。但这并不意味着神华、中建材未来不会关注 柔性 化的发展。 此外，与单多晶不同，所谓铜铟镓硒薄膜太阳能电池，是指使用化学物质Cu（铜）、In（铟）、Ga（镓）、Se（硒）通过共蒸发或后硒化工艺在衬底上形成吸收层的太阳能电池技术。在上述重庆神华不愿具名人士看来，目前，不论 共蒸发 还是 后硒化 其本质都是一样的， 应该说，两种生产环节上的不同，并没有为任何一方带来可以制胜的优势。","PubDate":"2018-01-11 08:19:00.000","MediaName":"中国证券网（上海证券报）","DuplicationID":null,"AnalyzeData":{"MarketIDs":["MK-WH"],"BlockIDs":["BL_MJS","BL_GFFD","BL_DJG"],"StockIDs":["sz000591","sh601727","sh601088","sh900925"],"IG":"{\"n\":\"FinancialIG\",\"w\":0.0,\"x\":false,\"l\":0,\"s\":[{\"n\":\"科技频道\",\"w\":4.72740841,\"x\":false,\"l\":1,\"s\":[{\"n\":\"光伏\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"产业\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"光电\",\"w\":1.30103,\"x\":true,\"l\":2},{\"n\":\"电站\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"低碳\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"神州\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"科技\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"芯片\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"量产\",\"w\":1.69897,\"x\":true,\"l\":2}]},{\"n\":\"能源频道\",\"w\":1.17571926,\"x\":false,\"l\":1,\"s\":[{\"n\":\"神华\",\"w\":1.95424247,\"x\":true,\"l\":2},{\"n\":\"太阳能\",\"w\":2.07918119,\"x\":true,\"l\":2},{\"n\":\"清洁\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"能源\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"发电\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"数据频道\",\"w\":2.433985,\"x\":false,\"l\":1,\"s\":[{\"n\":\"月份\",\"w\":1.47712123,\"x\":true,\"l\":2},{\"n\":\"水平\",\"w\":1.0,\"x\":true,\"l\":2},{\"n\":\"下降\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"环保频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"环境\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"政府政策频道\",\"w\":1.0339849,\"x\":false,\"l\":1,\"s\":[{\"n\":\"政府\",\"w\":1.47712123,\"x\":true,\"l\":2}]},{\"n\":\"外汇频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"欧元\",\"w\":1.0,\"x\":true,\"l\":2}]},{\"n\":\"汽车频道\",\"w\":0.7,\"x\":false,\"l\":1,\"s\":[{\"n\":\"汽车\",\"w\":1.0,\"x\":true,\"l\":2}]}]}"}},
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment