TensorFlow 的 Session 对象是支持多线程的，因此多个线程可以很方便地在同一个会话下对同一个队列并行地执行操作。Python 本身也提供了创建线程的threading.py，这个文件提供了Thread 类来创建线程，Thread 类的 start()函数可以用于启动线程。但是使用Python程序实现这样的并行运算没有那么简单，因为所有的线程需要能同步终止，同时需要正确察觉每个线程触发的异常。在会话终止的时候，操作队列的多个线程必须能被正确关闭。Tensorflow提供了两个类来实现多线程—train.Coordinator类和train,QueueRunner类。其中前者侧重于管理线程，用来协调同时停止多个工作线程或者在线程发生异常时向等待线程终止的程序报告异常；后者比较侧重于创建线程本身。
 
使用Coordinator类管理线程
 
Coordinator类的主要方法有should_stop()、request_stop()和join()，下面分别介绍这三个方法。should_stop()：通过函数的返回值判断线程是否停止，如果线程停止了，则函数返回True。request_stop()：请求该线程及其他线程停止。Join()：等待被指定的线程终止。接下来，以启动 Thread 创建的线程为例来说明 Coordinator 类及其3个函数用法。在启动线程之前，需要先声明一个 Coordinator 类，并将这个类传入每一个创建的线程中。这些线程通常一直循环运行，并一直查询Coordinator 类中提供的 should_stop()函数，直到 should_stop()返回值为 True时才退出当前的线程 。每一个启动的线程也可以通知其他启动的线程退出，它只需要调用 request_stop()函数即可：同时这个线程的 should stop()函数将会返回 True ，结果是所有线程都停下来。下面是实际代码操作：
 

 
在上面的代码中使用Thread类创建了5个线程，无论 5 个线程中的哪一个发出，request_stop()操作请求，这 5 个线程的 should_stop()函数返回值都会输出True,并且相应的发出 request_stop()操作请求的线程也会停止。下面是输出的结果：
 

 
使用QueueRunner创建线程
 
QueueRunner类主要用于替代Python自身的Thread类创建多个线程。但是需要注意的地方是，QueueRunner类必须配合Coordinator类一起使用。正确的操作流程是先使用QueueRunner类创建多个线程来操作同一个队列，这些线程会通过train,add_queue_runner()函数加入一个集合中，之后再调用train.start_queue_runners()函数来启动所有线程并通过参数来管理这些线程的Coordinator类。train.add_queue_runner()函数中如果没有指定自己的集合，那么这些线程会被加入到计算图默认的一个集合中(这里就不再赘述，只要了解就可以)。需要注意的是，这个函数只支持启动指定集合中的 QueueRnner，所以需要先将线程放入集合中。 一般的做法是把train.add_queue_runner()函数指定的集合与 train. start_queue_runner()函数指定的集合保持一致。 以下是操作代码：
 

 
上面的代码中，我们首先定义了一个队列，以及一个入队操作，之后通过QueueRunner类创建了5个线程来执行这个入队操作，调用start_queue_runners()函数来运行线程，最后打印出结果。如下图所示：
 

 
总结：本节有关使用多线程处理输入的数据的内容就到这里了，如果有没有看明白的可以实际上手操作一下，这样会更有利于理解消化。
 
关注小鲸融创，一起深度学习金融科技！
 

 
https://www.jianshu.com/p/6c64ec161c71

 
我试图在处理器的几个线程上运行这个Python代码，但是我找不到如何分配多个线程。我在Jupyter(以前叫I python)中使用的是python 2.7。
 
初始代码如下(所有这部分都工作得很好)。它是一个web解析器，它接受x，即我的列表中的一个url，即一个url列表，然后编写一个CSV(其中out_string是一行)。
 
不带多线程的代码my_list = ['http://stackoverflow.com/', 'http://google.com']
 
def main():
 
with open('Extract.csv'), 'w') as out_file:
 
count_loop = 0
 
for x in my_list:
 
#================ Get title ==================#
 
out_string = ""
 
campaign = parseCampaign(x)
 
out_string += ';' + str(campaign.getTitle())
 
#================ Get Profile ==================#
 
if campaign.getTitle() != 'NA':
 
creator = parseCreator(campaign.getCreatorUrl())
 
out_string += ';' + str(creator.getCreatorProfileLinkUrl())
 
else:
 
pass
 
#================ Write ==================#
 
out_string += '\n'
 
out_file.write(out_string)
 
count_loop +=1
 
print '---- %s on %s ------- ' %(count_loop, len(my_list))
 
多线程但无法工作的代码from threading import Thread
 
my_list = ['http://stackoverflow.com/', 'http://google.com']
 
def main(x):
 
with open('Extract.csv'), 'w') as out_file:
 
count_loop = 0
 
for x in my_list:
 
#================ Get title ==================#
 
out_string = ""
 
campaign = parseCampaign(x)
 
out_string += ';' + str(campaign.getTitle())
 
#================ Get Profile ==================#
 
if campaign.getTitle() != 'NA':
 
creator = parseCreator(campaign.getCreatorUrl())
 
out_string += ';' + str(creator.getCreatorProfileLinkUrl())
 
else:
 
pass
 
#================ Write ==================#
 
out_string += '\n'
 
out_file.write(out_string)
 
count_loop +=1
 
print '---- %s on %s ------- ' %(count_loop, len(my_list))
 
for x in my_list:
 
t = Thread(target=main, args=(x,))
 
t.start()
 
t2 = Thread(target=main, args=(x,))
 
t2.start()
 
我找不到一个好的方法来实现多个线程来运行这段代码，我有点困惑，因为文档不太容易理解。使用一个内核，这段代码需要2个小时，多线程将节省我很多时间！

一、功能说明
 
最近进行一个功能优化工作，涉及到数据的传输，由于散乱的小文件太多的缘故，因此在数据传输过程中非常慢。计划通过对文件夹进行压缩后传输二进制压缩包的方式提升网络传输效率。前期需要对某个目录下的所有文件夹逐个压缩为zip包，此处引入多线程处理和单线程处理，对比一下压缩速度。 代码并未提供全部，主要是为了记录多线程处理文件时参数分配以及进度界面显示问题。 
 
二、功能界面
 
 
三、执行效果
 

 
 
 
四、主要功能代码
 
// MutiThreadDlg.h : 头文件
//

#pragma once
#include "afxcmn.h"
#include "Myprogressctrl.h"

#include <vector>
#include <map>
#include "afxwin.h"
using namespace std;

struct threadInfo  
{  
	threadInfo()
	{
		nCodeNum = -1;
		pctrlProgress = NULL;
		ctrlTip = NULL;
		vecInfo.clear();
	}

	threadInfo::threadInfo(const threadInfo& other)
	{
		nCodeNum = other.nCodeNum;
		pctrlProgress = other.pctrlProgress;
		ctrlTip = other.ctrlTip;
		vecInfo.assign(other.vecInfo.begin(),other.vecInfo.end());
	}

	threadInfo& operator = (threadInfo& thInfo)
	{
		nCodeNum = thInfo.nCodeNum;
		pctrlProgress = thInfo.pctrlProgress;
		ctrlTip = thInfo.ctrlTip;
		vecInfo.assign(thInfo.vecInfo.begin(),thInfo.vecInfo.end());

		return* this;
	}

	~threadInfo()
	{

	}

	UINT nCodeNum;  
	std::vector<CString> vecInfo;
	CProgressCtrl* pctrlProgress;
	CStatic* ctrlTip;
};  

//DWORD WINAPI SingleThreadFunc(LPVOID lpParam);  
DWORD WINAPI MutiThreadFunc(LPVOID lpParam);  


// CMutiThreadDlg 对话框
class CMutiThreadDlg : public CDialogEx
{
// 构造
public:
	CMutiThreadDlg(CWnd* pParent = NULL);	// 标准构造函数

// 对话框数据
	enum { IDD = IDD_MUTITHREAD_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV 支持

// 实现
protected:
	HICON m_hIcon;

	// 生成的消息映射函数
	virtual BOOL OnInitDialog();
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()

public:
	afx_msg void OnBnClickedBtnMuti();
	afx_msg void OnBnClickedBtnSingle();
	afx_msg void OnBnClickedBtnFilepath();

	// 从指定目录读取所有文件夹名称
	void GetAllFolder(std::string path, vector<std::string>& vecFiles);

	CMyProgressCtrl m_ctrlProgress;
	CStatic m_ctrlTip;
	std::vector<threadInfo> m_vecInfo;	
};
 
// MutiThreadDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "MutiThread.h"
#include "MutiThreadDlg.h"
#include "afxdialogex.h"

#include "FileMiniZip.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

volatile UINT m_nFileCount = 0;
volatile UINT m_nOkCount = 0;
volatile long m_BeginTime = 0;

#define THRED_NUM  5

HANDLE m_hMutex; // 线程互斥

std::string wstring2string(wstring wstr)
{
	string result;
	int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);
	if( len <= 0 )return result;
	char* buffer = new char[len + 1];
	if(buffer == NULL )return result;
	WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);
	buffer[len] = '\0';
	result.append(buffer);
	delete[] buffer;

	return result;
}

std::wstring string2wstring(string str)
{
	wstring result;
	int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);
	if( len < 0 )return result;
	wchar_t* buffer = new wchar_t[len + 1];
	if( buffer == NULL )return result;
	MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);
	buffer[len] = '\0';
	result.append(buffer);
	delete[] buffer;

	return result;
}

bool UnZipPackage(PCTSTR szFile, PCTSTR szDestDir)
{
	std::wstring wsFile = szFile;
	std::string sZipFilePath = wstring2string(wsFile);

	std::wstring wsDestDir = szDestDir;
	std::string sUnZipToPath = wstring2string(wsDestDir);
	if (_tmkdir(wsDestDir.c_str()) != 0)
	{
		return false;
	}

	CFileMiniZip unzipTool;

	if (unzipTool.unZipPackageToLocal(sZipFilePath, sUnZipToPath) < 1)
	{
		return false;
	}

	return true;
}

bool ZipPackage(PCTSTR szSourcePath, PCTSTR szDestFile)
{
	CFileMiniZip unzipTool;

	std::wstring wsSourcePath = szSourcePath;
	std::string sSrcDirPath = wstring2string(wsSourcePath);

	std::wstring wsDestFile = szDestFile;
	std::string sZipFile = wstring2string(wsDestFile);

	if (unzipTool.CompressToPackageZip(sSrcDirPath, sZipFile) == 0)
	{
		return false;
	}

	return true;
}

DWORD WINAPI MutiThreadFunc(LPVOID lpParam)
{
	threadInfo* pInfo = (threadInfo*)lpParam;  
	int nCodeNum = pInfo->nCodeNum;
	std::vector<CString>& vecFileame = pInfo->vecInfo;

	for(int i = 0;i < vecFileame.size(); i++)  
	{  
		CString strFolder = vecFileame[i];
		CString strFolderZip = strFolder + _T(".zip");

		CString sMsg;
		sMsg.Format(_T("DEBUG:当前线程序号= %d，包含文件数量= %d，处理文件名称= %s, !"),nCodeNum,(int)vecFileame.size(),vecFileame[i]);
		OutputDebugString(sMsg);

		// 测试压缩
		if (!ZipPackage(strFolder,strFolderZip))
		{
			OutputDebugString(_T("DEBUG::压缩失败！"));
		}

		WaitForSingleObject(m_hMutex, INFINITE);

		++m_nOkCount;
		long dCurrentTime = GetTickCount64();
		double dTime = ((double)(dCurrentTime - m_BeginTime))/1000;
		CString sTip;
		sTip.Format(_T("当前处理完成个数 %d / %d，耗时 %.3f 秒,剩余 %d 个!"),m_nOkCount,m_nFileCount,dTime,m_nFileCount-m_nOkCount);
		pInfo->ctrlTip->SetWindowTextW(sTip);
		pInfo->pctrlProgress->SetPos(m_nOkCount);

		ReleaseMutex(m_hMutex);
	}  

	return 0;  
}

// CMutiThreadDlg 对话框

CMutiThreadDlg::CMutiThreadDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CMutiThreadDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CMutiThreadDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_PROGRESS, m_ctrlProgress);
	DDX_Control(pDX, IDC_STATIC_TEXT, m_ctrlTip);
}

BEGIN_MESSAGE_MAP(CMutiThreadDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BTN_MUTI, &CMutiThreadDlg::OnBnClickedBtnMuti)
	ON_BN_CLICKED(IDC_BTN_SINGLE, &CMutiThreadDlg::OnBnClickedBtnSingle)
	ON_BN_CLICKED(IDC_BTN_FILEPATH, &CMutiThreadDlg::OnBnClickedBtnFilepath)
END_MESSAGE_MAP()


// CMutiThreadDlg 消息处理程序

BOOL CMutiThreadDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标
	CString strFolderPath = _T("C:\\Users\\...\\Desktop\\..\\data");
	GetDlgItem(IDC_EDIT_FILEPATH)->SetWindowTextW(strFolderPath);

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CMutiThreadDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CMutiThreadDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CMutiThreadDlg::OnBnClickedBtnSingle()
{
	// TODO: 在此添加控件通知处理程序代码
	OutputDebugString(_T("DEBUG:开始执行单线程压缩"));

	// 获取目录下所有文件夹
	CString strDir;
	GetDlgItem(IDC_EDIT_FILEPATH)->GetWindowTextW(strDir);
	std::wstring wsDir = strDir;
	std::string sDir = wstring2string(wsDir);

	vector<std::string> vecFolders;
	GetAllFolder(sDir,vecFolders);
	if (vecFolders.size() == 0)
	{
		MessageBox(_T("所选目录为空！"));
		return;
	}

	m_vecInfo.clear();

	// 创建线程数据参数
	threadInfo thInfo;
	thInfo.nCodeNum = 0;
	thInfo.pctrlProgress = &m_ctrlProgress; 
	thInfo.ctrlTip = &m_ctrlTip;
	m_vecInfo.push_back(thInfo);

	m_nFileCount = (UINT)vecFolders.size();
	m_ctrlProgress.SetPos(0);
	m_ctrlProgress.SetRange(0,m_nFileCount);

	for (unsigned int n = 0; n < vecFolders.size(); ++n)
	{
		string sTemp = vecFolders[n];
		wstring wsTemp = string2wstring(sTemp);
		CString strTemp = (LPCTSTR)wsTemp.c_str();
		m_vecInfo[0].vecInfo.push_back(strTemp);
	}

	// 防止多次点击创建多个锁
	if (m_hMutex)
	{
		CloseHandle(m_hMutex);
		m_hMutex = NULL;
	}

	m_hMutex = CreateMutex(NULL, FALSE, _T("CompressPro"));
	m_BeginTime = GetTickCount64();

	threadInfo& sInfoTemp = m_vecInfo.at(0);
	DWORD ThreadID;
	HANDLE hThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)MutiThreadFunc,&sInfoTemp,0,&ThreadID);
	CloseHandle(hThread);
}

void CMutiThreadDlg::OnBnClickedBtnMuti()
{
	// TODO: 在此添加控件通知处理程序代码
	OutputDebugString(_T("DEBUG:开始执行多线程压缩"));

	// 获取目录下所有文件夹
	CString strDir;
	GetDlgItem(IDC_EDIT_FILEPATH)->GetWindowTextW(strDir);
	std::wstring wsDir = strDir;
	std::string sDir = wstring2string(wsDir);

	vector<std::string> vecFolders;
	GetAllFolder(sDir,vecFolders);
	if (vecFolders.size() == 0)
	{
		MessageBox(_T("所选目录为空！"));
		return;
	}
	
	m_vecInfo.clear();
	m_vecInfo.reserve(THRED_NUM);

	// 创建线程数据参数数组
	for (UINT n = 0; n < THRED_NUM; ++n)
	{
		threadInfo thInfo;
		thInfo.nCodeNum = n;
		thInfo.pctrlProgress = &m_ctrlProgress; 
		thInfo.ctrlTip = &m_ctrlTip;
		m_vecInfo.push_back(thInfo);
	}

	m_nFileCount = (UINT)vecFolders.size();
	m_ctrlProgress.SetPos(0);
	m_ctrlProgress.SetRange(0,m_nFileCount);

	UINT nFileNum = 0;
	for (unsigned int n = 0; n < vecFolders.size(); ++n)
	{
		string sTemp = vecFolders[n];
		wstring wsTemp = string2wstring(sTemp);
		CString strTemp = (LPCTSTR)wsTemp.c_str();
		m_vecInfo[nFileNum].vecInfo.push_back(strTemp);
		++nFileNum;

		if(nFileNum > THRED_NUM-1)
		{
			nFileNum = 0;
		}
	}

	// 防止多次点击创建多个锁
	if (m_hMutex)
	{
		CloseHandle(m_hMutex);
		m_hMutex = NULL;
	}

	m_hMutex = CreateMutex(NULL, FALSE, _T("CompressPro"));
	m_BeginTime = GetTickCount64();

	for (int i = 0; i < THRED_NUM; ++i)
	{
		threadInfo& sInfoTemp = m_vecInfo.at(i);
		DWORD ThreadID;
		HANDLE hThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)MutiThreadFunc,&sInfoTemp,0,&ThreadID);
		CloseHandle(hThread);
	}
}

void CMutiThreadDlg::OnBnClickedBtnFilepath()
{
	// TODO: 在此添加控件通知处理程序代码
	TCHAR szFolderPath[MAX_PATH] = {0};
	CString strFolderPath;
	BROWSEINFO sInfo;
	ZeroMemory(&sInfo, sizeof(BROWSEINFO));

	sInfo.pidlRoot = 0;
	sInfo.lpszTitle = _T("请选择一个文件夹：");
	sInfo.ulFlags = BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_EDITBOX;
	sInfo.lpfn = NULL;

	// 显示文件夹选择对话框
	LPITEMIDLIST lpidlBrowse = SHBrowseForFolder(&sInfo);
	if (lpidlBrowse != NULL)
	{
		// 取得文件夹名
		if (SHGetPathFromIDList(lpidlBrowse,szFolderPath))
		{
			strFolderPath = szFolderPath;
		}
	}
	if(lpidlBrowse != NULL)
	{
		CoTaskMemFree(lpidlBrowse);
	}

	GetDlgItem(IDC_EDIT_FILEPATH)->SetWindowTextW(strFolderPath);
}

void CMutiThreadDlg::GetAllFolder(std::string path, vector<std::string>& vecFolders)
{
	// 文件句柄
	intptr_t hFile = 0;

	// 文件信息
	struct _finddata_t fileinfo;  

	string p;
	if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1) 
	{
		do 
		{
			// 保存文件的全路径
			char* pPath = fileinfo.name;
			if ( strcmp(pPath,".") == 0 || strcmp(pPath,"..") == 0 )
			{
				continue;
			}

			vecFolders.push_back(p.assign(path).append("\\").append(fileinfo.name));

		} while (_findnext(hFile, &fileinfo) == 0);  //寻找下一个，成功返回0，否则-1

		_findclose(hFile);
	}
}
 
下载地址：https://download.csdn.net/download
 
注意：未加入界面控件保护，在执行过程可能误触，建议使用时自己加入界面保护。

 
importorg.apache.log4j.Logger;importorg.apache.poi.hssf.usermodel.HSSFRow;importorg.apache.poi.hssf.usermodel.HSSFSheet;importorg.apache.poi.hssf.usermodel.HSSFWorkbook;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.ResponseBody;importorg.springframework.web.bind.annotation.RestController;importorg.springframework.web.multipart.MultipartFile;importjavax.servlet.http.HttpServletRequest;importjava.text.SimpleDateFormat;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.concurrent.CountDownLatch;importjava.util.concurrent.ScheduledThreadPoolExecutor;importjava.util.concurrent.ThreadPoolExecutor;/** * Created by admin
 
*/
 
@RestController
 
@RequestMapping("/importData")public class HpImportController extendsBaseController{private static final Logger logger = Logger.getLogger(HpImportController.class);
 
@Reference(interfaceClass= SidCustManageService.class,version = Constants.SERVICE_VERSION)privateSidCustManageService sidCustManageService;
 
@RequestMapping(value= "importDate")
 
@ResponseBodypublicResponse getOrdertDate(HttpServletRequest request,MultipartFile importData){//创建Excel工作薄
 
try{
 
HSSFWorkbook hwb= newHSSFWorkbook(importData.getInputStream());//得到第一个工作表
 
HSSFSheet sheet = hwb.getSheetAt(0);
 
HSSFRow row= null;
 
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
 
List list = new ArrayList();//遍历该表格中所有的工作表，i表示工作表的数量 getNumberOfSheets表示工作表的总数
 
for(int i = 0; i < hwb.getNumberOfSheets(); i++) {
 
sheet=hwb.getSheetAt(i);//遍历该行所有的行,j表示行数 getPhysicalNumberOfRows行的总数
 
for(int j = 1; j < sheet.getPhysicalNumberOfRows(); j++) {
 
row=sheet.getRow(j);
 
String loginName= ExcelUtils.getStringValue(row, 0);
 
String agentName= ExcelUtils.getStringValue(row, 1);
 
String pwd= "123123";
 
String amount= ExcelUtils.getStringValue(row, 3);
 
String cust_lev= ExcelUtils.getStringValue(row,4);
 
String name= ExcelUtils.getStringValue(row, 5);
 
String tel= ExcelUtils.getStringValue(row, 6);
 
String qq= ExcelUtils.getStringValue(row, 7);
 
String birday= ExcelUtils.getStringValue(row, 8);
 
String email= ExcelUtils.getStringValue(row, 9);
 
String createTp= ExcelUtils.getStringValue(row, 10);
 
String bankAccountName= ExcelUtils.getStringValue(row, 11);
 
String bankNo= ExcelUtils.getStringValue(row, 12);
 
String bankName= ExcelUtils.getStringValue(row, 13);
 
String bankType= ExcelUtils.getStringValue(row, 14);
 
SidCustPersonContactInfo custCpci= newSidCustPersonContactInfo();
 
custCpci.setCustCode(loginName);
 
custCpci.setAmount(Double.valueOf(amount));
 
custCpci.setPasswd(pwd);
 
custCpci.setBankName(bankName);
 
custCpci.setBankNo(bankNo);
 
custCpci.setBankAccountName(bankAccountName);if(!birday.equals("")){
 
custCpci.setBirthDate(sdf.parse(birday));
 
}
 
custCpci.setFirstName(name);
 
custCpci.setNickName(name);
 
custCpci.setQq(qq);
 
custCpci.setBankType(bankType);
 
custCpci.setEmailAddress(email);
 
custCpci.setMobileNumber(tel);
 
custCpci.setHallId(Long.valueOf(5));
 
list.add(custCpci);
 
}
 
}int count = 50;int listSize =list.size();int RunSize = (listSize / count)+1;
 
ThreadPoolExecutor executor= newScheduledThreadPoolExecutor(RunSize);
 
CountDownLatch countDownLatch= newCountDownLatch(RunSize);
 
List newList = null;for (int i = 0; i < RunSize; i++) {if((i+1)==RunSize){int startIndex = (i*count);;int endIndex =list.size();
 
newList=list.subList(startIndex,endIndex);
 
}else{int startIndex = i*count;;int endIndex = (i+1)*count;
 
newList=list.subList(startIndex,endIndex);
 
}
 
ExecupteHp hpRunnable= newExecupteHp(newList);
 
executor.execute(hpRunnable);
 
}
 
countDownLatch.await();
 
executor.shutdown();
 
}catch(Exception e){logger.info("导入数据开始.");
 
e.printStackTrace();
 
}return Response.ok(GlobalEnum.GLOBAL_ENUM_SUCCESS_CODE.getValue() , SidCustEnum.SID_CRST_ERROR_SID_SUCCESS_07.getValue());
 
}class ExecupteHp implementsRunnable{private List list;public ExecupteHp (List list){this.list =list ;
 
}
 
@Overridepublic voidrun() {if(null!=list){for(SidCustPersonContactInfo scpc : list){
 
System.out.print("更新会员联系方式" +scpc.getFirstName() + "---"+scpc.getCustCode() );
 
SidCustContactInfo custContactInfo= newSidCustContactInfo();
 
custContactInfo.setCustCode(scpc.getCustCode());
 
custContactInfo.setEmailAddress(scpc.getEmailAddress());
 
custContactInfo.setMobileNumber(scpc.getMobileNumber());
 
custContactInfo.setFirstName(scpc.getFirstName());
 
custContactInfo.setNicName(scpc.getNickName());
 
custContactInfo.setQq(scpc.getQq());
 
custContactInfoService.updateByContactByCustCode(custContactInfo);
 
}
 
}
 
}
 
}
 
}