2. 程式人生 > >Windows C++ 執行緒池

Windows C++ 執行緒池

阿新 • • 發佈：2019-01-29

        Windows 平臺C++ 沒什麼比較好的官方的執行緒池，boost裡倒是有很方便的執行緒池，可是為了一個執行緒池，使用龐大的boost顯然不太合適，為此，我在網上找了個demo，然後用C++模板做了些改造，基本上實現了類似boost的threadpool的功能。

首先需要解釋的是，以何種方式將執行緒函式加入佇列（我這裡用的佇列是CList），可以利用類模板和函式模板以及函式指標建立包含該函式的物件，執行時，只需要呼叫物件中的函式指標即可，這裡說明下，因為函式模板在例項化之前是沒有任何函式的，因此，自然就不存在指向函式模板的指標。但是可以以另一種方式建立函式模板的指標，即引入類模板。因為類模板例項化之後，其中的函式模板就有意義了。但是，這也出現了個問題，就是類模板中的函式模板無法作為函式指標在類外呼叫，例如在該標頭檔案對應的cpp檔案中呼叫。因此，不得已需要直接在標頭檔案中定義函式體。

#pragma once

#include "Task.h"
#include <typeinfo>
class ParamTem
{
protected:
	ParamTem(){};
};


template <class ReturnType,class P0=ParamTem,class P1=ParamTem,
class P2=ParamTem,class P3=ParamTem, class P4=ParamTem,
class P5=ParamTem,class P6=ParamTem, class P7=ParamTem>
class CMyTask: public CTask,public ParamTem
{
private:
	typedef ReturnType (*FuncTem)();
	typedef ReturnType (*FuncTem0)(P0 p0);
	typedef ReturnType (*FuncTem1)(P0 p0, P1 p1);
	typedef ReturnType (*FuncTem2)(P0 p0, P1 p1, P2 p2);
	typedef ReturnType (*FuncTem3)(P0 p0, P1 p1, P2 p2,P3 p3);
	typedef ReturnType (*FuncTem4)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4);
	typedef ReturnType (*FuncTem5)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5);
	typedef ReturnType (*FuncTem6)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6);
	typedef ReturnType (*FuncTem7)(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7);
	FuncTem ft;
	FuncTem0 ft0;
	FuncTem1 ft1;
	FuncTem2 ft2;
	FuncTem3 ft3;
	FuncTem4 ft4;
	FuncTem5 ft5;
	FuncTem6 ft6;
	FuncTem7 ft7;
	P0 p0;
	P1 p1;
	P2 p2;
	P3 p3;
	P4 p4;
	P5 p5;
	P6 p6;
	P7 p7;
public:
	CMyTask(FuncTem ft)
	{
		this->ft = ft;
	}
	CMyTask(FuncTem0 ft,P0 p0)
	{
		this->ft0 = ft;
		this->p0 = p0;
	}
	CMyTask(FuncTem1 ft,P0 p0, P1 p1)
	{
		this->ft1 = ft;
		this->p0 = p0;
		this->p1 = p1;
	}
	CMyTask(FuncTem2 ft,P0 p0, P1 p1, P2 p2)
	{
		this->ft2 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
	}
	CMyTask(FuncTem3 ft,P0 p0, P1 p1, P2 p2, P3 p3)
	{
		this->ft3 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
	}
	CMyTask(FuncTem4 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)
	{
		this->ft4 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
	}
	CMyTask(FuncTem5 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)
	{
		this->ft5 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
	}
	CMyTask(FuncTem6 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6)
	{
		this->ft6 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
		this->p6 = p6;
	}
	CMyTask(FuncTem7 ft,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7)
	{
		this->ft7 = ft;
		this->p0 = p0;
		this->p1 = p1;
		this->p2 = p2;
		this->p3 = p3;
		this->p4 = p4;
		this->p5 = p5;
		this->p6 = p6;
		this->p7 = p7;
	}
	virtual void Run()
	{
		if(!strcmp(typeid(P0).name(),"class ParamTem"))
		{
			this->ft();
		}
		else if(!strcmp(typeid(P1).name(),"class ParamTem"))
		{
			this->ft0(this->p0);
		}
		else if(!strcmp(typeid(P2).name(),"class ParamTem"))
		{
			this->ft1(this->p0,this->p1);
		}
		else if(!strcmp(typeid(P3).name(),"class ParamTem"))
		{
			this->ft2(this->p0,this->p1,this->p2);
		}
		else if(!strcmp(typeid(P4).name(),"class ParamTem"))
		{
			this->ft3(this->p0,this->p1,this->p2,this->p3);
		}
		else if(!strcmp(typeid(P5).name(),"class ParamTem"))
		{
			this->ft4(this->p0,this->p1,this->p2,this->p3,this->p4);
		}
		else if(!strcmp(typeid(P6).name(),"class ParamTem"))
		{
			this->ft5(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5);
		}
		else if(!strcmp(typeid(P7).name(),"class ParamTem"))
		{
			this->ft6(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5\
				,this->p6);
		}
		else if(strcmp(typeid(P7).name(),"class ParamTem"))
		{
			this->ft7(this->p0,this->p1,this->p2,this->p3,this->p4,this->p5\
				,this->p6,this->p7);
		}
	}
};
如上只定義了到含8個引數的函式模板，如果你們需要執行的函式的引數可能更多，只需要依葫蘆畫瓢，新增相應的函式模板即可。

另外定義這個類模板是因為在將函式加入佇列貌似不太好辦，我也不確定辦不了，但是我是沒搞出來，所以需要藉助物件來儲存函式。
這裡說明兩個地方，首先為什麼要定義一個父類，而且，父類的建構函式是protected許可權的，這個為了避免其他地方呼叫這個類生成物件，因為它是MyTask的預設模板引數，預設模板引數則是為了避免參數較少時依然要填滿所以的模板引數宣告。

#include "StdAfx.h"
#include "MyThreadPool.h"

CMyThreadPool::CMyThreadPool(int nThreadCount/* =5 */)
{
	this->m_nThreadCount=nThreadCount; 
	m_bthreadflag = TRUE;
	m_hsemaphore = CreateSemaphore(NULL, 0, 5000, NULL);
	InitializeCriticalSection(&m_csThreadQueue);
	InitializeCriticalSection(&m_csTaskQueue);
	m_pThreadItemList=new std::list<ThreadItem*>;
	m_pTaskList=new std::list<CTask*>;
	EnterCriticalSection(&m_csThreadQueue);
	for (int i=0;i<m_nThreadCount;i++)
	{
		ThreadItem* pItem=new ThreadItem();
		if (pItem)
		{
			pItem->pThreadPool=this;
			pItem->bThreadFlag=TRUE;
			pItem->hThreadHandle= (HANDLE)_beginthreadex(NULL, 0, ThreadFunc, (LPVOID)pItem, 0, &pItem->dwThreadID);
			printf("建立執行緒 threadid:%d\n",pItem->dwThreadID);
			m_pThreadItemList->push_back(pItem);
		}
	}
	LeaveCriticalSection(&m_csThreadQueue);
}

UINT WINAPI CMyThreadPool::ThreadFunc(LPVOID lpParameter /* = NULL */)
{
	//CMyThreadPool* pmyThreadPool = (CMyThreadPool*) lpParameter;
	ThreadItem *pItem = (ThreadItem*) lpParameter;
	CTask * m_pTask = NULL;
	while(pItem->bThreadFlag)
	{
		WaitForSingleObject(pItem->pThreadPool->m_hsemaphore, INFINITE);
		EnterCriticalSection(&pItem->pThreadPool->m_csTaskQueue);
		m_pTask = pItem->pThreadPool->m_pTaskList->front();
		if(m_pTask)
		{
			pItem->pThreadPool->m_pTaskList->pop_front();
		}
		LeaveCriticalSection(&pItem->pThreadPool->m_csTaskQueue);
		m_pTask->Run();
		delete m_pTask;
	}
	return NULL;
}

void CMyThreadPool::StopAllThread()
{
	EnterCriticalSection(&m_csThreadQueue);
	while (!m_pThreadItemList->empty())
	{		
		ThreadItem* pThreadItem=m_pThreadItemList->front();
		if (pThreadItem)
		{
			//TRACE("結束執行緒 %d\n",pThreadItem->dwThreadID);
			printf("結束執行緒 %d\n",pThreadItem->dwThreadID);
			pThreadItem->bThreadFlag=FALSE;
			WaitForSingleObject(pThreadItem->hThreadHandle,INFINITE);
			m_pThreadItemList->pop_front();
			delete(pThreadItem);			
		}		
	}
	LeaveCriticalSection(&m_csThreadQueue);
}


void CMyThreadPool::schedule(CTask* pTask)
{	
	EnterCriticalSection(&m_csTaskQueue);
	if (m_pTaskList)
	{
		m_pTaskList->push_back(pTask);
	}
	ReleaseSemaphore(this->m_hsemaphore,1,NULL);
	LeaveCriticalSection(&m_csTaskQueue);
}

CMyThreadPool::~CMyThreadPool()
{
	StopAllThread();
	DeleteCriticalSection(&m_csThreadQueue);
	DeleteCriticalSection(&m_csTaskQueue);
	delete m_pTaskList;
	delete m_pThreadItemList;
}
這是執行緒池原始碼，當然正如我在上面所說道的函式模板的問題，在此，其定義的另一個schedule函式需要在標頭檔案中直接定義。
#pragma once
#include "MyTask.h"
#include <list>
#include <process.h>
class CMyThreadPool;
struct ThreadItem
{
	HANDLE hThreadHandle;       //執行緒控制代碼
	UINT  dwThreadID;          //執行緒ID
	BOOL   bThreadFlag;         //執行緒執行標識
	CMyThreadPool* pThreadPool;   //屬於哪個執行緒池
	ThreadItem()
	{
		hThreadHandle=NULL;
		dwThreadID=0;
		bThreadFlag=FALSE;
		pThreadPool=NULL;
	}
};

class CMyThreadPool
{
public:
	//CMyThreadPool();
	CMyThreadPool(int nThreadCount=5);
	virtual ~CMyThreadPool();
	static UINT WINAPI ThreadFunc(LPVOID lpParameter = NULL);
public:
	void schedule(CTask* pTask);
	std::list<ThreadItem*>* GetThreadItemList() {return m_pThreadItemList;};
	std::list<CTask*>*      GetTaskList() {return m_pTaskList;};
	void               StopAllThread();
	void               AdjustSize(int nThreadCount);  //動態調整執行緒池規模
protected:
	//static 
private:
	BOOL m_bthreadflag;   
	int m_nThreadCount;    //執行緒池中執行緒的個數
	HANDLE m_hsemaphore;
	std::list<ThreadItem*>*  m_pThreadItemList;
	std::list<CTask*>*       m_pTaskList;
	CRITICAL_SECTION    m_csThreadQueue;
	CRITICAL_SECTION    m_csTaskQueue;

	//Schedule 函式定義

public:
	template<typename ReturnType>
	void schedule(ReturnType Func())
	{
		CTask * pTask = new CMyTask<ReturnType>(Func);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
public:
	template <typename ReturnType, typename P0>
	void schedule(ReturnType Func(P0 p0),P0 p0)
	{
		CTask * pTask = new CMyTask<ReturnType,P0>(Func, p0);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1>
	void schedule(ReturnType Func(P0 p0, P1 p1),P0 p0, P1 p1)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1>(Func, p0, p1);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2),P0 p0, P1 p1, P2 p2)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2>(Func, p0, p1, p2);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3),P0 p0, P1 p1, P2 p2, P3 p3)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3>(Func, p0, p1, p2, p3);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)\
	,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4>(Func, p0, p1, p2, p3, p4);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
		,typename P4, typename P5>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)\
	,P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5>(Func, p0, p1, p2, p3, p4, p5);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4, typename P5, typename P6>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6),\
	P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5,P6>(Func, p0, p1, p2, p3, p4, p5, p6);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
	template <typename ReturnType, typename P0, typename P1,typename P2, typename P3\
	,typename P4, typename P5, typename P6,typename P7>
	void schedule(ReturnType Func(P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7),\
	P0 p0, P1 p1, P2 p2, P3 p3,P4 p4, P5 p5, P6 p6, P7 p7)
	{
		CTask * pTask = new CMyTask<ReturnType,P0,P1,P2,P3,P4,P5,P6,P7>(Func, p0, p1, p2, p3, p4, p5, p6,p7);
		EnterCriticalSection(&m_csTaskQueue);
		if (m_pTaskList)
		{
			m_pTaskList->push_back(pTask);
		}
		ReleaseSemaphore(this->m_hsemaphore,1,NULL);
		LeaveCriticalSection(&m_csTaskQueue);
	}
};

這裡我用到了一個訊號量和一個臨界區來保證執行緒安全，訊號量的作用是每有一個執行的物件加入佇列，就+1，反之就-1，然後利用WaitforSingleObject來讓所有執行緒等待。臨界區就不用說了，這是為了保證MyTask物件的佇列的執行緒安全的。

最後附上執行緒池原始碼下載地址http://download.csdn.net/detail/yuguanquan1990/8109379

相關推薦

Windows C++ 執行緒池

        Windows 平臺C++ 沒什麼比較好的官方的執行緒池，boost裡倒是有很方便的執行緒池，可是為了一個執行緒池，使用龐大的boost顯然不太合適，為此，我在網上找了個demo，然後用C++模板做了些改造，基本上實現了類似boost的threadpool的

C++執行緒池實現

最近讀了muduo的原始碼，看了一下其中執行緒池的是實現。其中互斥量、條件變數都是庫裡面自己封裝的，正好現在C++標準庫裡面有對應的類，所以就改造了一下，補充了部分註釋。同時總結了一下條件變數和鎖的使用。程式碼如下： ThreadPool.h #pragma once #incl

簡單Linux C執行緒池

#include "threadpool.h"struct threadpool* threadpool_init(int thread_num, int queue_max_num){struct threadpool *pool = NULL;do { pool = malloc

白話跨平臺C++執行緒池實現

執行緒池在一個C++專案中是必不可少的。去看任何一個C++開發框架，絕大部分都會實現一個執行緒池。而如今C++11已經成熟，藉助C++標準庫中的執行緒庫std::thread，以及標準庫提供的多執行緒同步神器std::condition_variable(這個已

Linux C++ 執行緒池

標頭檔案定義： 話不多說，先上程式碼： 注意：本文程式碼來源於https://github.com/progschj/ThreadPool.git 不需要註釋，想要乾淨程式碼的可以直接上GitHub去找資源 標頭檔案 執行緒池類程式碼 /* * Date : 2018/7/24 * Aut

C# 執行緒池中取消執行緒的三種方式

三種方式都使用CancellationToken，只是使用方式不同，有類似於採用全域性標誌位的方式 第一種 檢測IsCancellationRequested方式 static void AsyncOperation1(CancellationToken t

c++執行緒池的實現

https://github.com/Wchenguang/ThreadPool/ github 傳送門 ------------------ 1.使用例項 //測試job寫檔案 class job : public WJob{ private: int a; f

[C++][執行緒池][完整實現] 轉：執行緒池原理及建立（C++實現）

文章的主要框架是參考這篇文件的，http://jacky-dai.iteye.com/blog/1090285, 關於作者  張中慶，西安交通大學軟體所，在讀碩士，目前研究方向為分散式網路與移動中介軟體，對Linux極其愛好，可以通過[email protecte

轉載一份C++執行緒池的程式碼，非常實用

基本上是拿來就用了，對WIN32 API不熟，但對執行緒池的邏輯還是比較熟的，認為這個執行緒池寫得很清晰，我拿來用在一個多執行緒下載的模組中。很實用的東東。 呼叫方法 void threadfunc(void *p) {      YourClass* your

linux c++執行緒池的實現（多執行緒伺服器）

        本文給出了一個通用的執行緒池框架，該框架將與執行緒執行相關的任務進行了高層次的抽象，使之與具體的執行任務無關。另外該執行緒池具有動態伸縮性，它能根據執行 任務的輕重自動調整執行緒池中執行緒的數量。文章的最後，我們給出一個簡單示例程式，通過該示例程式，我們會發

一份C++執行緒池的程式碼，非常實用

#ifndef _ThreadPool_H_ #define _ThreadPool_H_ #pragma warning(disable: 4530) #pragma warning(disable: 4786) #include <cassert> #in

c++執行緒池

      本文給出了一個通用的執行緒池框架，該框架將與執行緒執行相關的任務進行了高層次的抽象，使之與具體的執行任務無關。另外該執行緒池具有動態伸縮性，它能根據執行任務的輕重自動調整執行緒池中執行緒的數量。文章的最後，我們給出一個簡單示例程式，通過該示例程式，我們會發現，通過該執行緒池框架執行多執行緒任務是多

C# 執行緒池簡單用法

最簡單的單執行緒運用是直接建立一個Thread物件再呼叫satrt(),此方法丟擲一個執行緒後將不再管它,讓其自生自滅... private void MessageShow(string msg, string title, MessageBoxIcon

基於C++11實現執行緒池的工作原理.

基於C++11實現執行緒池的工作原理. 文章目錄 基於C++11實現執行緒池的工作原理. 簡介 執行緒池的組成 1、執行緒池管理器 2、工作執行緒 3、任務介面， 4、任務佇列

典型C/S模式___執行緒池實現

一、多執行緒和執行緒池的區別 執行緒池 多執行緒 同時啟動若干個執行緒，持續存在，時刻準備處理請求 來一個請求啟動一個執行緒 響應時間短 響應時間較長 二、執行緒池

基於C++11實現執行緒池的工作原理

基於C++11實現執行緒池的工作原理. 不久前寫過一篇執行緒池，那時候剛用C++寫東西不久，很多C++標準庫裡面的東西沒怎麼用，今天基於C++11重新實現了一個執行緒池。 簡介 執行緒池（thread pool）：一種執行緒的使用模式，執行緒過多會帶來排程開銷，進而影響快取區域性性和整體效能。而執行緒池

c++11多執行緒與執行緒池

最近需要開發一個高效能運算庫，涉及到c++多執行緒的應用，上次做類似的事情已經是4年多以前了，印象中還頗有些麻煩。悔當初做了就算了，也沒想著留點記錄什麼的。這次又研究了一番，發現用上c++11特性之後，現在已經比較簡單了，在此記錄一下。   最簡單的多執行緒情況，不涉及公共變數，各個執行緒之間獨

基於C++11的執行緒池

*需要C++11的支援,在vs2013下編譯通過 執行效果 背景 在傳統的收到任務即建立執行緒的情況下，我們每收到一個任務，就建立一個執行緒，執行任務，銷燬執行緒， 我們把這三個過程所用的時間分別記做T1,T2,T3 任務本身所用的時間僅佔T2/(T1+T2+T3),這在任務本身所用時間很短的情況下

基於C++11的執行緒池(threadpool),簡潔且可以帶任意多的引數（轉）

咳咳。C++11 加入了執行緒庫，從此告別了標準庫不支援併發的歷史。然而 c++ 對於多執行緒的支援還是比較低階，稍微高階一點的用法都需要自己去實現，譬如執行緒池、訊號量等。執行緒池(thread pool)這個東西，在面試上多次被問到，一般的回答都是：“管理一個任務佇列，一個執行緒佇列，然後每次取一個任務分

C# 連線mysql,連線後顯示多個執行緒池

資料庫連線字串 return string.Concat(new string[]             {      &n