Ⅰ python寫一個後台的守護進程
importos,sys,commands,time
defdaemonize(stdin='/dev/null',stdout='/dev/null',stderr='/dev/null'):
"""setdaemonize"""
try:
pid=os.fork()
ifpid>0:
sys.exit(0)
exceptOSError,e:
sys.stderr.write("fork#1failed(%d)%s "%(e.errno,e.strerror))
sys.exit(0)
os.setsid()
os.chdir('.')
os.umask(0)
try:
pid=os.fork()
ifpid>0:
sys.exit(0)
exceptOSError,e:
sys.stderr.write("fork#2failed(%d)%s "%(e.errno,e.strerror))
sys.exit(0)
ifnotstderr:stderr=stdout
si=file(stdin,"r")
so=file(stdout,"w+")
se=file(stderr,"a+")
pid=str(os.getpid())
print"startwithpid:[%s]"%pid
fp=open("pid","w")
print>>fp,pid
fp.close()
sys.stderr.flush()
sys.stdout.flush()
sys.stderr.flush()
os.p2(si.fileno(),sys.stdin.fileno())
os.p2(so.fileno(),sys.stdout.fileno())
os.p2(se.fileno(),sys.stderr.fileno())
defmain():
daemonize(stdout='test.log',stderr='test.log')
cmd="ls"
while1:
(status,ret)=commands.getstatusoutput(cmd)
printstatus
printret
time.sleep(10)
if__name__=="__main__":
main()
你可以嘗試照這個寫寫，基本的元素都齊了，後台運行，執行shell命令
不過如果只是想要後台的話，直接shell後台執行一下也就可以了
Ⅱ 如何使用Python實現多進程編程
1.Process
創建進程的類：Process([group[,target[,name[,args[,kwargs]]]]])，target表示調用對象，args表示調用對象的位置參數元組。kwargs表示調用對象的字典。name為別名。group實質上不使用。
方法：is_alive()、join([timeout])、run()、start()、terminate()。其中，Process以start()啟動某個進程。
屬性：authkey、daemon（要通過start()設置）、exitcode(進程在運行時為None、如果為–N，表示被信號N結束）、name、pid。其中daemon是父進程終止後自動終止，且自己不能產生新進程，必須在start()之前設置。
例1.1：創建函數並將其作為單個進程
importmultiprocessing
importtime
defworker(interval):
n=5
whilen>0:
print("Thetimeis{0}".format(time.ctime()))
time.sleep(interval)
n-=1
if__name__=="__main__":
p=multiprocessing.Process(target=worker,args=(3,))
p.start()
print"p.pid:",p.pid
print"p.name:",p.name
print"p.is_alive:",p.is_alive()
結果
12345678p.pid:8736p.name:Process-1p.is_alive:TrueThetimeisTueApr2120:55:122015ThetimeisTueApr2120:55:152015ThetimeisTueApr2120:55:182015ThetimeisTueApr2120:55:212015ThetimeisTueApr2120:55:242015
例1.2：創建函數並將其作為多個進程
importmultiprocessing
importtime
defworker_1(interval):
print"worker_1"
time.sleep(interval)
print"endworker_1"
defworker_2(interval):
print"worker_2"
time.sleep(interval)
print"endworker_2"
defworker_3(interval):
print"worker_3"
time.sleep(interval)
print"endworker_3"
if__name__=="__main__":
p1=multiprocessing.Process(target=worker_1,args=(2,))
p2=multiprocessing.Process(target=worker_2,args=(3,))
p3=multiprocessing.Process(target=worker_3,args=(4,))
p1.start()
p2.start()
p3.start()
print("ThenumberofCPUis:"+str(multiprocessing.cpu_count()))
forpinmultiprocessing.active_children():
print("childp.name:"+p.name+" p.id"+str(p.pid))
print"END!!!!!!!!!!!!!!!!!"
結果
1234567891011ThenumberofCPUis:4childp.name:Process-3p.id7992childp.name:Process-2p.id4204childp.name:Process-1p.id6380END!!!!!!!!!!!!!!!!!worker_1worker_3worker_2endworker_1endworker_2endworker_3
例1.3：將進程定義為類
importmultiprocessing
importtime
classClockProcess(multiprocessing.Process):
def__init__(self,interval):
multiprocessing.Process.__init__(self)
self.interval=interval
defrun(self):
n=5
whilen>0:
print("thetimeis{0}".format(time.ctime()))
time.sleep(self.interval)
n-=1
if__name__=='__main__':
p=ClockProcess(3)
p.start()
註：進程p調用start()時，自動調用run()
結果
12345thetimeisTueApr2120:31:302015thetimeisTueApr2120:31:332015thetimeisTueApr2120:31:362015thetimeisTueApr2120:31:392015thetimeisTueApr2120:31:422015
Ⅲ python怎麼實現一個進程
想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。
開辟子進程
multiprocessing中提供了Process類來生成進程實例
Process([group [, target [, name [, args [, kwargs]]]]])1
group分組，實際上不使用
target表示調用對象，你可以傳入方法的名字
args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可
kwargs表示調用對象的字典
name是別名，相當於給這個進程取一個名字
先來個小例子：
運行結果：
Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017
根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。
通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。
有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。
執行結果：
Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017
這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼
執行結果：
subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017
這樣所有的進程就能順利的執行了。
將進程定義成類
通過繼承Process類，來自定義進程類，實現run方法。實例p通過調用p.start()時自動調用run方法。
如下：
執行結果和上一個例子相同。
創建多個進程
很多時候系統都需要創建多個進程以提高CPU的利用率，當數量較少時，可以手動生成一個個Process實例。當進程數量很多時，或許可以利用循環，但是這需要程序員手動管理系統中並發進程的數量，有時會很麻煩。這時進程池Pool就可以發揮其功效了。可以通過傳遞參數限制並發進程的數量，默認值為CPU的核數。
直接上例子：
執行結果：
開頭部分
Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)
末尾部分：
Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.
相關說明：
這里進程池對並發進程的限制數量為8個，而程序運行時會產生16個進程，進程池將自動管理系統內進程的並發數量，其餘進程將會在隊列中等待。限制並發數量是因為，系統中並發的進程不是越多越好，並發進程太多，可能使CPU大部分的時間用於進程調度，而不是執行有效的計算。
採用多進程並發技術時，就單個處理機而言，其對進程的執行是串列的。但具體某個時刻哪個進程獲得CPU資源而執行是不可預知的（如執行結果的開頭部分，各進程的執行順序不定），這就體現了進程的非同步性。
如果單個程序執行14次run_proc函數，那麼它會需要至少16秒,通過進程的並發，這里只需要2.49秒，可見並發的優勢。
Ⅳ 如何在Python中編寫並發程序
GIL
在Python中,由於歷史原因(GIL),使得Python中多線程的效果非常不理想.GIL使得任何時刻Python只能利用一個CPU核,並
且它的調度演算法簡單粗暴:多線程中,讓每個線程運行一段時間t,然後強行掛起該線程,繼而去運行其他線程,如此周而復始,直到所有線程結束.
這使得無法有效利用計算機系統中的"局部性",頻繁的線程切換也對緩存不是很友好,造成資源的浪費.
據說Python官方曾經實現了一個去除GIL的Python解釋器,但是其效果還不如有GIL的解釋器,遂放棄.後來Python官方推出了"利
用多進程替代多線程"的方案,在Python3中也有concurrent.futures這樣的包,讓我們的程序編寫可以做到"簡單和性能兼得".
多進程/多線程+Queue
一般來說,在Python中編寫並發程序的經驗是:計算密集型任務使用多進程,IO密集型任務使用多進程或者多線程.另外,因為涉及到資源共享,所
以需要同步鎖等一系列麻煩的步驟,代碼編寫不直觀.另外一種好的思路是利用多進程/多線程+Queue的方法,可以避免加鎖這樣麻煩低效的方式.
現在在Python2中利用Queue+多進程的方法來處理一個IO密集型任務.
假設現在需要下載多個網頁內容並進行解析,單進程的方式效率很低,所以使用多進程/多線程勢在必行.
我們可以先初始化一個tasks隊列,裡面將要存儲的是一系列dest_url,同時開啟4個進程向tasks中取任務然後執行,處理結果存儲在一個results隊列中,最後對results中的結果進行解析.最後關閉兩個隊列.
下面是一些主要的邏輯代碼.
# -*- coding:utf-8 -*-
#IO密集型任務
#多個進程同時下載多個網頁
#利用Queue+多進程
#由於是IO密集型,所以同樣可以利用threading模塊
import multiprocessing
def main():
tasks = multiprocessing.JoinableQueue()
results = multiprocessing.Queue()
cpu_count = multiprocessing.cpu_count() #進程數目==CPU核數目
create_process(tasks, results, cpu_count) #主進程馬上創建一系列進程,但是由於阻塞隊列tasks開始為空,副進程全部被阻塞
add_tasks(tasks) #開始往tasks中添加任務
parse(tasks, results) #最後主進程等待其他線程處理完成結果
def create_process(tasks, results, cpu_count):
for _ in range(cpu_count):
p = multiprocessing.Process(target=_worker, args=(tasks, results)) #根據_worker創建對應的進程
p.daemon = True #讓所有進程可以隨主進程結束而結束
p.start() #啟動
def _worker(tasks, results):
while True: #因為前面所有線程都設置了daemon=True,故不會無限循環
try:
task = tasks.get() #如果tasks中沒有任務,則阻塞
result = _download(task)
results.put(result) #some exceptions do not handled
finally:
tasks.task_done()
def add_tasks(tasks):
for url in get_urls(): #get_urls() return a urls_list
tasks.put(url)
def parse(tasks, results):
try:
tasks.join()
except KeyboardInterrupt as err:
print "Tasks has been stopped!"
print err
while not results.empty():
_parse(results)
if __name__ == '__main__':
main()
利用Python3中的concurrent.futures包
在Python3中可以利用concurrent.futures包,編寫更加簡單易用的多線程/多進程代碼.其使用感覺和Java的concurrent框架很相似(借鑒?)
比如下面的簡單代碼示例
def handler():
futures = set()
with concurrent.futures.ProcessPoolExecutor(max_workers=cpu_count) as executor:
for task in get_task(tasks):
future = executor.submit(task)
futures.add(future)
def wait_for(futures):
try:
for future in concurrent.futures.as_completed(futures):
err = futures.exception()
if not err:
result = future.result()
else:
raise err
except KeyboardInterrupt as e:
for future in futures:
future.cancel()
print "Task has been canceled!"
print e
return result
總結
要是一些大型Python項目也這般編寫,那麼效率也太低了.在Python中有許多已有的框架使用,使用它們起來更加高效.
Ⅳ 如何部署python web程序
Python Web 程序的部署方案
綜合而言, 高性能的Python web站點部署方式首推 nginx + uwsgi
apache + mod_wsgi 是簡單穩定但性能一般的方式
API伺服器 可以直接使用tornado或者gevent
mod_python
非常原始的cgi模式部署python已經沒有什麼好介紹了。對於不太追求性能的管理系統和網站來說，使用 Apache 部署是一個不錯的選擇。較早的時候，使用 mode_python 部署python的web應用十分流行,在Django 0.96 的時候官方文檔甚至推薦這種方式。
它將Python解釋器嵌入到Apache server,以提供一個訪問Apache server內部的介面。mod_python 在現在看來性能是不佳的，每一個http請求 mod_python 都會由一個進程初始化python解釋器、載入代碼、執行、然後銷毀進程。
mod_wsgi
如果非要用Apache來部署python應用，mod_wsgi是一個更好的選擇。WSGI 全稱是 Web Server Gateway Interface ,由 PEP-333 定義。 基本上所有的python web框架都實現了wsgi介面，用mod_wsgi 能部署任何實現了wsgi的框架。實際上，不需要任何框架也可以用mod_wsgi 部署python程序。使用mod_wsgi的daemon模式，python程序會常駐內存，不會有很大的初始化和銷毀進程方面的開銷，所以性能是好於mod_python的。綜合來說，使用Apache部署python web程序，推薦使用mod_wsgi的daemon模式。
Fastcgi
先說觀點：不建議用fastcgi的方式部署Python web。
前幾年由於lighttpd風頭正勁和豆瓣的成功案例，fastcgi是一種很流行的部署方式。fastcgi與具體語言無關，也與web伺服器無關。是一種通用的部署方式。fastcgi是對於cgi的增強，CGI程序運行在獨立的進程中，並對每個Web請求建立一個進程。面對大量請求，進程的大量建立和消亡使操作系統性能大大下降。
與為每個請求創建一個新的進程不同，FastCGI使用持續的進程來處理一連串的請求。這些進程由FastCGI伺服器管理，而不是web伺服器。 當進來一個請求時，web伺服器把環境變數和這個頁面請求通過一個socket比如FastCGI進程與web伺服器都位於本地）或者一個TCP connection（FastCGI進程在遠端的server farm）傳遞給FastCGI進程。
主流的web伺服器，Apache,lighttpd,nginx 都支持fastcgi，在幾年前，lighttpd的mod_fcgi模塊性能強勁，lighttpd+fastcgi十分流行。無論是python,ruby還是php，都有大量的站點使用這種方式部署。由於nginx的崛起，現在很少有人使用lighttpd了。
fastcgi 並不是專門為python設計，並不是所有的python框架天然的支持fastcgi，通常需要flup這樣的容器來配適。flup由python編寫，和專門的c實現的wsgi容器比起來性能顯得相當不堪。fastcgi的穩定性對於新興的wsgi容器來說也有差距。無論從哪個方面來看，部署python web程序，fastcgi 都已經是過去式。
uwsgi
前幾年nginx還未內置uwsgi模塊的時候，部署uwsgi還是一件挺麻煩的事情。隨著能夠在nginx中直接使用uwsgi模塊，uwsgi已經是最可靠，最方便的高性能python web程序的部署方式了。
在1U的四核XEON伺服器上，一個簡單的wsgi handler甚至能用AB壓到8000以上的qps,這已經是完爆tornado,接近gevent的性能了。 同時，uwsgi的穩定性極好。之前我們有個每天500w-1000w動態請求的站點使用uwsgi部署非常穩定，在一個渣HP 1U 伺服器上，基本不用管它。
上面提到的部署方式都是相對於web網站的方式，在移動互聯網的時代，我們需要的是高性能的API服務，上面這些都是過時的東西。
tornado
tornado 號稱高性能，如果拿他寫網站，其實一般般，只不過跟uwsgi加一些簡單框架差不多而已。它真正的作用，是用來寫API伺服器和長連接的伺服器。
由於tornado能夠直接處理http請求，很多人直接拿他來裸奔直接提供服務。這種方式是不可取的，單線程的tornado只能利用cpu的一個核心，並且一旦阻塞直接就廢了。通常情況下，由supervisor啟動多個tornado進程，通過nginx進行反向代理負載均衡。nginx 1.14 以後的版本反向代理支持長連接，配合tornado的comet效果很好。
tornado還有一些比較奇葩的用法，比如用來做wsgi容器之類的。
gevent
gevent是一個神器，能做的事情很多。在web方面，處理http請求，用起來其實跟tornado差不多，但是要簡陋很多，cookie之類的都沒有。用gevent寫的一些API服務，部署方式還是類似tornado，用supervisor管理多個守護進程，通過nginx做負載均衡。 同樣的它的奇葩用法也和tornado一樣，可以當wsgi容器用。
Ⅵ python daemon thread 什麼概念
daemon
A boolean value indicating whether this thread is a daemon thread (True) or not (False). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False.
The entire Python program exits when no alive non-daemon threads are left.
當daemon被設置為True時，如果主線程退出，那麼子線程也將跟著退出，
反之，子線程將繼續運行，直到正常退出。
Ⅶ python 多線程和多進程的區別 mutiprocessing theading
在socketserver服務端代碼中有這么一句：
server = socketserver.ThreadingTCPServer((ip,port), MyServer)
ThreadingTCPServer這個類是一個支持多線程和TCP協議的socketserver，它的繼承關系是這樣的：
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
右邊的TCPServer實際上是主要的功能父類，而左邊的ThreadingMixIn則是實現了多線程的類，ThreadingTCPServer自己本身則沒有任何代碼。
MixIn在Python的類命名中很常見，稱作「混入」，戲稱「亂入」，通常為了某種重要功能被子類繼承。
我們看看一下ThreadingMixIn的源代碼：
class ThreadingMixIn:
daemon_threads = False
def process_request_thread(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
t = threading.Thread(target = self.process_request_thread,
args = (request, client_address))
t.daemon = self.daemon_threads
t.start()
在ThreadingMixIn類中，其實就定義了一個屬性，兩個方法。其中的process_request()方法實際調用的正是Python內置的多線程模塊threading。這個模塊是Python中所有多線程的基礎，socketserver本質上也是利用了這個模塊。
socketserver通過threading模塊，實現了多線程任務處理能力，可以同時為多個客戶提供服務。
那麼，什麼是線程，什麼是進程？
進程是程序（軟體，應用）的一個執行實例，每個運行中的程序，可以同時創建多個進程，但至少要有一個。每個進程都提供執行程序所需的所有資源，都有一個虛擬的地址空間、可執行的代碼、操作系統的介面、安全的上下文（記錄啟動該進程的用戶和許可權等等）、唯一的進程ID、環境變數、優先順序類、最小和最大的工作空間（內存空間）。進程可以包含線程，並且每個進程必須有至少一個線程。每個進程啟動時都會最先產生一個線程，即主線程，然後主線程會再創建其他的子線程。
線程，有時被稱為輕量級進程(Lightweight Process，LWP），是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC），寄存器集合和堆棧組成。另外，線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不獨立擁有系統資源，但它可與同屬一個進程的其它線程共享該進程所擁有的全部資源。每一個應用程序都至少有一個進程和一個線程。在單個程序中同時運行多個線程完成不同的被劃分成一塊一塊的工作，稱為多線程。
舉個例子，某公司要生產一種產品，於是在生產基地建設了很多廠房，每個廠房內又有多條流水生產線。所有廠房配合將整個產品生產出來，單個廠房內的流水線負責生產所屬廠房的產品部件，每個廠房都擁有自己的材料庫，廠房內的生產線共享這些材料。公司要實現生產必須擁有至少一個廠房一條生產線。換成計算機的概念，那麼這家公司就是應用程序，廠房就是應用程序的進程，生產線就是某個進程的一個線程。
線程的特點：
線程是一個execution context（執行上下文），即一個cpu執行時所需要的一串指令。假設你正在讀一本書，沒有讀完，你想休息一下，但是你想在回來時繼續先前的進度。有一個方法就是記下頁數、行數與字數這三個數值，這些數值就是execution context。如果你的室友在你休息的時候，使用相同的方法讀這本書。你和她只需要這三個數字記下來就可以在交替的時間共同閱讀這本書了。
線程的工作方式與此類似。CPU會給你一個在同一時間能夠做多個運算的幻覺，實際上它在每個運算上只花了極少的時間，本質上CPU同一時刻只能幹一件事，所謂的多線程和並發處理只是假象。CPU能這樣做是因為它有每個任務的execution context，就像你能夠和你朋友共享同一本書一樣。
進程與線程區別：
同一個進程中的線程共享同一內存空間，但進程之間的內存空間是獨立的。
同一個進程中的所有線程的數據是共享的，但進程之間的數據是獨立的。
對主線程的修改可能會影響其他線程的行為，但是父進程的修改（除了刪除以外）不會影響其他子進程。
線程是一個上下文的執行指令，而進程則是與運算相關的一簇資源。
同一個進程的線程之間可以直接通信，但是進程之間的交流需要藉助中間代理來實現。
創建新的線程很容易，但是創建新的進程需要對父進程做一次復制。
一個線程可以操作同一進程的其他線程，但是進程只能操作其子進程。
線程啟動速度快，進程啟動速度慢（但是兩者運行速度沒有可比性）。
由於現代cpu已經進入多核時代，並且主頻也相對以往大幅提升，多線程和多進程編程已經成為主流。Python全面支持多線程和多進程編程，同時還支持協程。
Ⅷ python daemon=True有什麼作用
定義一個變數daemon = True
這樣後面調用使用使用
例如
if daemon:
while daemon:
當為真的時候執行後面的語句，因為定義了變數，當為假時候不執行 daemon=False
Ⅸ 如何將一個python以daemon的方式運行
你可以使用python-daemon這個庫，用法很簡單。
地址：https://pypi.python.org/pypi/python-daemon/2.0.5
importdaemon
fromspamimportdo_main_program
withdaemon.DaemonContext():
do_main_program()
如果解決了您的問題請採納！
如果未解決請繼續追問
Ⅹ python多線程問題
以下方式都可以解決這個問題：
啟動的時候可以在命令末尾加上 &，表示在後台執行。
可以使用 supervisord, upstart, systemd等管理工具來啟動你的程序。
把你的程序daemon化，可以使用 python-daemon 等庫來實現。