Day39~40-进程线程

import os

print(‘父进程 (%s) 启动‘ % os.getpid())
pid = os.fork()
if pid == 0:
    print(‘子进程 (%s) , 父进程 %s‘ % (os.getpid(), os.getppid()))
else:
    print(‘父进程 (%s) , 创建了子进程 (%s)‘ % (os.getpid(), pid))

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print(‘子进程 %s (%s)...‘ % (name, os.getpid()))

if __name__==‘__main__‘:
    print(‘父进程 %s.‘ % os.getpid())
    p = Process(target=run_proc, args=(‘sub_process‘,))
    print(‘启动子进程.‘)
    p.start()
    p.join()
    print(‘子进程结束.‘)

from multiprocessing import Pool
import os
import time
import random

def pool_run(name):
    print("启动子进程{}, pid:{}".format(name, os.getpid()))
    start_time = time.time()
    # 睡0~3秒
    time.sleep(random.random()*3)
    print("进程{}运行{:.2f}秒".format(name, time.time() - start_time))

if __name__ == ‘__main__‘:
    print("父进程{}".format(os.getpid()))
    my_pool = Pool(4)
    for i in range(5):
        my_pool.apply_async(pool_run, args=(i,))
    print("等待子进程结束")
    # 执行了close()就无法继续添加新的Process
    my_pool.close()
    my_pool.join()
    print("程序结束")

import subprocess

r = subprocess.call([‘tracert‘, ‘www.baidu.com‘])
print(‘Exit code:‘, r)

import subprocess

print(‘$ nslookup‘)
p = subprocess.Popen([‘nslookup‘], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b‘set q=mx\npython.org\nexit\n‘)
print(output.decode(‘utf-8‘))
print(‘Exit code:‘, p.returncode)

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    print(‘写进程%s‘ % os.getpid())
    for value in [‘A‘, ‘B‘, ‘C‘]:
        print(‘发送消息: %s‘ % value)
        q.put(value)
        # 如果不睡的话, 一下子就把消息写到队列中了
        # time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    print(‘读进程: %s‘ % os.getpid())
    while True:
        value = q.get(True)
        print(‘得到消息: %s‘ % value)

if __name__==‘__main__‘:
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    # 生成两个对象, 一个发送消息, 一个接受消息
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

import time
import random
import threading

def sub_thread():
    print("子线程{}启动".format(threading.current_thread().name))
    n = 0
    while n < 5:
        n += 1
        print("{}输出消息{}".format(threading.current_thread().name, n))
        time.sleep(random.random()*2)
    print("子线程结束")

# 主线程的名字是MainThread
print("主线程{}启动".format(threading.current_thread().name))
t = threading.Thread(target=sub_thread, name="my_sub_thread")
t.start()
t.join()
print("主线程{}结束".format(threading.current_thread().name))

import threading
import time

class MyThread(threading.Thread):

    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num=num

    def run(self):
        print("running on number:%s" %self.num)
        time.sleep(3)

t1=MyThread(56)
t2=MyThread(78)

t1.start()
t2.start()
print("ending")

import time, threading

# 假定这是你的银行存款:
balance = 0
lock = threading.Lock()


def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    lock.acquire()
    balance = balance + n
    lock.release()

def run_thread(n):
    for i in range(100000):
        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

import threading
import time

mutexA = threading.Lock()
mutexB = threading.Lock()

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):
        mutexA.acquire()
        print("{} func1 拿到mutexA".format(threading.current_thread().name))
        mutexB.acquire()
        print("{} func1 拿到mutexB".format(threading.current_thread().name))
        mutexB.release()
        mutexA.release()


    def fun2(self):
        mutexB.acquire()
        print("{} func2 拿到mutexA".format(threading.current_thread().name))
        # 如果不睡眠, 那么就不一定出现死锁
        time.sleep(0.2)
        mutexA.acquire()
        print("{} func2 拿到mutexB".format(threading.current_thread().name))
        mutexA.release()
        mutexB.release()

if __name__ == "__main__":
    for i in range(0, 10):
        my_thread = MyThread()
        my_thread.start()

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG, format=‘(%(threadName)-10s) %(message)s‘,)

# def worker(event):
#     logging.debug(‘等待redis启动‘)
#     event.wait()
#     logging.debug(‘redis启动完毕, 正在使用 [%s]‘, time.ctime())
#     time.sleep(1)

def worker(event):
    while not event.is_set():
        logging.debug(‘等待redis启动‘)
        event.wait(1)
    logging.debug(‘redis启动完毕, 正在使用 [%s]‘, time.ctime())
    time.sleep(1)

def main():
    readis_ready = threading.Event()
    t1 = threading.Thread(target=worker, args=(readis_ready,), name=‘t1‘)
    t1.start()

    t2 = threading.Thread(target=worker, args=(readis_ready,), name=‘t2‘)
    t2.start()

    logging.debug(‘主程序在3秒钟后启动redis‘)
    time.sleep(3)
    readis_ready.set()

if __name__=="__main__":
    main()

import threading
import time

semaphore = threading.Semaphore(5)

def func():
    if semaphore.acquire():
        print (threading.currentThread().getName() + ‘得到了一个信号量‘)
        time.sleep(2)
        semaphore.release()

for i in range(20):
  t1 = threading.Thread(target=func)
  t1.start()

import time,random
import queue,threading

q = queue.Queue()

def Producer():
  count = 0
  while count <3:
    print("生产者正在生产")
    time.sleep(random.randrange(1))
    q.put(count)
    print(‘生产者 生产的第 %s 个产品‘ % count)
    count +=1

def Consumer():
  count = 0
  while count <5:
    time.sleep(random.randrange(2))
    if not q.empty():
        data = q.get()
        print(‘\033[32;1m  消费者消费产品 %s \033[0m‘ % data )
    else:
        print("\033[32;1m  现在没有产品可以消费 \033[0m")
    count +=1

p1 = threading.Thread(target=Producer)
c1 = threading.Thread(target=Consumer)
p1.start()
c1.start()