python進程的tty_Python中的進程是什麼

❶ 簡述python進程，線程和協程的區別

協程多與線程進行比較
1) 一個線程可以多個協程，一個進程也可以單獨擁有多個協程，這樣python中則能使用多核CPU。
2) 線程進程都是同步機制，而協程則是非同步
3) 協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態

❷ python subprocess.popen 怎麼獲取到tty

def getmask(): command='for /f "delims=: tokens=2" %i in (\'ipconfig ^| findstr 子網掩碼\') do echo %i' Popen(command,shell=True)

❸ python 怎麼查看signal

信號（signal）--進程之間通訊的方式，是一種軟體中斷。一個進程一旦接受到信號就會打斷原來的程序執行流程來處理信號。

幾個常用信號:

SIGINT 終止進程中斷進程 (control+c)

SIGTERM 終止進程軟體終止信號

SIGKILL 終止進程殺死進程

SIGALRM 鬧鍾信號

進程結束信號 SIGTERM和SIGKILL的區別

SIGTERM比較友好，進程能捕捉這個信號，根據您的需要來關閉程序。在關閉程序之前，您可以結束打開的記錄文件和完成正在做的任務。在某些情況下，假如進程正在進行作業而且不能中斷，那麼進程可以忽略這個SIGTERM信號。

對於SIGKILL信號，進程是不能忽略的。這是一個「我不管您在做什麼,立刻停止」的信號。假如您發送SIGKILL信號給進程，Linux就將進程停止在那裡。

發送信號一般有兩種原因:

1(被動式) 內核檢測到一個系統事件.例如子進程退出會像父進程發送SIGCHLD信號.鍵盤按下control+c會發送SIGINT信號

2(主動式) 通過系統調用kill來向指定進程發送信號

補充：
POSIX.1中列出的信號：

信號值處理動作發出信號的原因

----------------------------------------------------------------------

SIGHUP 1 A 終端掛起或者控制進程終止
SIGINT 2 A 鍵盤中斷（如break鍵被按下）
SIGQUIT 3 C 鍵盤的退出鍵被按下
SIGILL 4 C 非法指令
SIGABRT 6 C 由abort(3)發出的退出指令
SIGFPE 8 C 浮點異常
SIGKILL 9 AEF Kill信號
SIGSEGV 11 C 無效的內存引用
SIGPIPE 13 A 管道破裂: 寫一個沒有讀埠的管道
SIGALRM 14 A 由alarm(2)發出的信號
SIGTERM 15 A 終止信號

SIGUSR1 30,10,16 A 用戶自定義信號1

SIGUSR2 31,12,17 A 用戶自定義信號2
SIGCHLD 20,17,18 B 子進程結束信號
SIGCONT 19,18,25 進程繼續（曾被停止的進程）
SIGSTOP 17,19,23 DEF 終止進程
SIGTSTP 18,20,24 D 控制終端（tty）上按下停止鍵
SIGTTIN 21,21,26 D 後台進程企圖從控制終端讀
SIGTTOU 22,22,27 D 後台進程企圖從控制終端寫

處理動作一項中的字母含義如下:
A 預設的動作是終止進程
B 預設的動作是忽略此信號
C 預設的動作是終止進程並進行內核映像轉儲（mp core）
D 預設的動作是停止進程
E 信號不能被捕獲
F 信號不能被忽略

鍵盤和shell的交互：

Ctrl-c Kill foreground process 常用 ;送SIGINT信號，默認進程會結束，但是進程自己可以重定義收到這個信號的行為。
Ctrl-z Suspend foreground process;送SIGSTOP信號，進程只是被停止，再送SIGCONT信號，進程繼續運行。
Ctrl-d Terminate input, or exit shell 常用有時也會使程序退出，例如沒有參數的cat命令，從終端讀一行顯示一行，知道Ctrl+D終結輸入並終結進程;不是發送信號，而是表示一個特殊的二進制值，表示 EOF。
Ctrl-s Suspend output
Ctrl-q Resume output
Ctrl-o Discard output
Ctrl-l Clear screen
控制字元都是可以用(stty命令)更改的。可以用stty -a看看終端配置。

有些信號不能被屏蔽，比如中斷，還應該有殺死進程的信號，要不然內核怎麼做操作系統中的老大。實際上，SIGKILL和SIGSTOP信號是不能被屏蔽或阻止的，他們的默認動作總是會被執行的

❹ Python中的進程是什麼

什麼是進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。在早期面向進程設計的計算機結構中，進程是程序的基本執行實體；在當代面向線程設計的計算機結構中，進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。

狹義定義：進程是正在運行的程序的實例（an instance of a computer program that is being executed）。

廣義定義：進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動。它是操作系統動態執行的基本單元，在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元。

進程的概念主要有兩點：第一，進程是一個實體。每一個進程都有它自己的地址空間，一般情況下，包括文本區域（text region）、數據區域（data region）和堆棧（stack region）。文本區域存儲處理器執行的代碼；數據區域存儲變數和進程執行期間使用的動態分配的內存；堆棧區域存儲著活動過程調用的指令和本地變數。第二，進程是一個「執行中的程序」。程序是一個沒有生命的實體，只有處理器賦予程序生命時（操作系統執行之），它才能成為一個活動的實體，我們稱其為進程。

相關推薦：

Python中的進程是什麼

❼ python 多進程問題

兩個進程如果要同時運行，star函數挨著一起寫

❽ python進程間通信怎麼理解

在2.6才開始使用
multiprocessing 是一個使用方法類似threading模塊的進程模塊。允許程序員做並行開發。並且可以在UNIX和Windows下運行。
通過創建一個Process 類型並且通過調用call()方法spawn一個進程。

一個比較簡單的例子：
#!/usr/bin/env python

from multiprocessing import Process
import time
def f(name):
time.sleep(1)
print 'hello ',name
print os.getppid() #取得父進程ID
print os.getpid() #取得進程ID
process_list = []
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間通信：
有兩種主要的方式：Queue、Pipe
1- Queue類幾乎就是Queue.Queue的復制，示例：
#!/usr/bin/env python

from multiprocessing import Process,Queue
import time
def f(name):
time.sleep(1)
q.put(['hello'+str(name)])
process_list = []
q = Queue()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for i in range(10):
print q.get()
2- Pipe 管道
#!/usr/bin/env python

from multiprocessing import Process,Pipe
import time
import os

def f(conn,name):
time.sleep(1)
conn.send(['hello'+str(name)])
print os.getppid(),'-----------',os.getpid()
process_list = []
parent_conn,child_conn = Pipe()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(child_conn,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for p in range(10):
print parent_conn.recv()
Pipe()返回兩個連接類，代表兩個方向。如果兩個進程在管道的兩邊同時讀或同時寫，會有可能造成corruption.

進程間同步
multiprocessing contains equivalents of all the synchronization primitives from threading.
例如，可以加一個鎖，以使某一時刻只有一個進程print
#!/usr/bin/env python

from multiprocessing import Process,Lock
import time
import os

def f(name):
lock.acquire()
time.sleep(1)
print 'hello--'+str(name)
print os.getppid(),'-----------',os.getpid()
lock.release()
process_list = []
lock = Lock()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間共享狀態 Sharing state between processes
當然盡最大可能防止使用共享狀態，但最終有可能會使用到.
1-共享內存
可以通過使用Value或者Array把數據存儲在一個共享的內存表中
#!/usr/bin/env python

from multiprocessing import Process,Value,Array
import time
import os

def f(n,a,name):
time.sleep(1)
n.value = name * name
for i in range(len(a)):
a[i] = -i
process_list = []
if __name__ == '__main__':
num = Value('d',0.0)
arr = Array('i',range(10))
for i in range(10):
p = Process(target=f,args=(num,arr,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print num.value
print arr[:]
輸出：
jimin@Jimin:~/projects$ python pp.py
81.0
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
'd'和'i'參數是num和arr用來設置類型，d表示一個雙精浮點類型，i表示一個帶符號的整型。
更加靈活的共享內存可以使用multiprocessing.sharectypes模塊

Server process
Manager()返回一個manager類型，控制一個server process，可以允許其它進程通過代理復制一些python objects
支持list,dict,Namespace,Lock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value,Array
例如：
#!/usr/bin/env python

from multiprocessing import Process,Manager
import time
import os

def f(d,name):
time.sleep(1)
d[name] = name * name
print d
process_list = []
if __name__ == '__main__':
manager = Manager()
d = manager.dict()
for i in range(10):
p = Process(target=f,args=(d,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print d
輸出結果：
{2: 4}
{2: 4, 3: 9}
{2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
Server process managers比共享內存方法更加的靈活，一個單獨的manager可以被同一網路的不同計算機的多個進程共享。
比共享內存更加的緩慢

使用工作池Using a pool of workers
Pool類代表 a pool of worker processes.
It has methods which allows tasks to be offloaded to the worker processes in a few different ways.

❾ Python中進程和線程的區別詳解

什麼是進程（Process）：普通的解釋就是，進程是程序的一次執行，而什麼是線程（Thread），線程可以理解為進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別：進程間是獨立的，這表現在內存空間，上下文環境；線程運行在進程空間內。一般來講（不使用特殊技術）進程是無法突破進程邊界存取其他進程內的存儲空間；而線程由於處於進程空間內，所以同一進程所產生的線程共享同一內存空間。同一進程中的兩段代碼不能夠同時執行，除非引入線程。線程是屬於進程的，當進程退出時該進程所產生的線程都會被強制退出並清除。線程佔用的資源要少於進程所佔用的資源。進程和線程都可以有優先順序。在線程系統中進程也是一個線程。可以將進程理解為一個程序的第一個線程。

線程是指進程內的一個執行單元,也是進程內的可調度實體.與進程的區別:(1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間;(2)進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源(3)線程是處理器調度的基本單位,但進程不是.(4)二者均可並發執行.

導航:首頁 > 編程語言 > python進程的tty

python進程的tty

與python進程的tty相關的資料