线程进程学习

# encoding: utf-8
"""
@author: lileilei
@site:
@software: PyCharm
@file: login.py
@time: 2017/7/26 10:28
"""
import  requests,time
from  multiprocessing import  Pool
url=‘http://www.jd.com‘
total=0
suc=0
fail=0
ecept=0
maxtime=0
mintime=0
gt3=0
lt3=0
def  baiduGent():
    global total
    global suc
    global  fail
    global  gt3
    global lt3
    global ecept
    try:
        st=time.time()
        conn=requests.get(url)
        res=conn.status_code
        if res==200:
            total+=1
            suc+=1
        else:
            total+=1
            fail+=1
        time_span = time.time() - st
        print(time_span)
        if time_span>3:
            gt3+=1
        else:
            lt3+=1
    except Exception as e:
        print(e)
        total+=1
        ecept+=1
if __name__ ==‘__main__‘:
    print(‘===========请求开始===========‘)
    start_time = time.time()
    pools = Pool(100)
    for i in range(10):
        pools.apply_async(baiduGent,args=())
    pools.close()
    pools.join()
from multiprocessing import Process,Queue
import os, time, random
def write(q):
    print(‘Process to 产生: %s‘ % os.getpid())
    for value in [‘苹果‘, ‘香蕉‘, ‘橘子‘]:
        print(‘产生 %s to queue...‘ % value)
        q.put(value)
        time.sleep(random.random())
def read(q):
    print(‘Process to 消费: %s‘ % os.getpid())
    while True:
        value = q.get()
        print(‘消费 %s from queue.‘ % value)
if __name__==‘__main__‘:
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pr.start()
    pw.join()
    pr.terminate()
m=list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(m)
f=list(map(lambda x:True if x%3==0 else False,range(100)))
print(f)
import asyncio
@asyncio.coroutine
async def hello():
    print (‘hello word‘)
    r=await asyncio.sleep(1)
    print(‘hello  again‘)
loop=asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()
import threading
import asyncio

@asyncio.coroutine
def hello():
    print(‘Hello world! (%s)‘ % threading.currentThread())
    yield from asyncio.sleep(1)
    print(‘Hello again! (%s)‘ % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
import asyncio
@asyncio.coroutine
def wget(host):
    print(‘wegt %s ....‘%host)
    connt=asyncio.open_connection(host,80)
    reder,writer=yield from connt
    hserd= ‘GET / HTTP/1.0\r\nHost: %s\r\n\r\n‘ % host
    writer.write(hserd.encode(‘utf-8‘))
    yield from writer.drain()
    while 1:
        line=yield from reder.readline()
        if line ==b‘\r\n‘:
            break
        print(‘%s header > %s‘ % (host, line.decode(‘utf-8‘).rstrip()))
        writer.close()
loop=asyncio.get_event_loop()
tasks=[wget(host) for host in [‘www.sina.com.cn‘, ‘www.sohu.com‘, ‘www.163.com‘]]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
import asyncio
from aiohttp import web
async def index(request):
    await asyncio.sleep(0.5)
    return web.Response(body=b‘<h1>Index</h1>‘,content_type=‘text/html‘)
async def hello(request):
    await asyncio.sleep(0.5)
    text = ‘<h1>hello, %s!</h1>‘ % request.match_info[‘name‘]
    return web.Response(body=text.encode(‘utf-8‘),content_type=‘text/html‘)
async def init(loop):
    app = web.Application(loop=loop)
    app.router.add_route(‘GET‘, ‘/‘, index)
    app.router.add_route(‘GET‘, ‘/hello/{name}‘, hello)
    srv = await loop.create_server(app.make_handler(), ‘127.0.0.1‘, 8000)
    print(‘Server started at http://127.0.0.1:8000...‘)
    return srv
loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
loop.run_forever()
import asyncio,time
@asyncio.coroutine
async def hello():
    print (‘hello word‘)
start_time=time.time()
loop=asyncio.get_event_loop()
tasks=[]
for i in range(10000):
    tasks.append(hello())
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
print(‘异步处理时间:%s‘%(time.time()-start_time))
import time,gevent
def print_s(num):
    st=time.time()
    conn=requests.get(‘http://www.jd.com‘)
    res=conn.status_code
    if res==200:
        print(‘chenggong‘)
    else:
        print(‘shibai‘)
start_time=time.time()
events=[gevent.spawn(print_s,num)for num in range(10000)]
gevent.joinall(events)
print(‘协程时间:%s‘%(time.time()-start_time))
时间: 2024-10-08 00:42:02

线程进程学习的相关文章

线程 进程学习

1,进程与线程 进程优点:同时利用多个cpu 工作,能同时进行多个操作 效率高 进程缺点:浪费内存 线程优点:共享内存,io操作的时候可以并发 线程缺点:抢占资源 进程不是越多越好  最好= cpu 线程也不是越多越好 具体案例 具体分析 请求上下文切换好时 计算机中执行任务最小单位是线程 IO密集型(不用cpu): 多线程 计算密集型(用cpu): 多进程 创建线程: import threading def f1(a): pass t = threading.Thread(target=f1

线程简单学习2

一.理解多线程 多线程是这样一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个线程,彼此间互相独立.线程又称为轻量级进程,它和进程一样拥有独立的执行控制,由操作系统负责调度,区别在于线程没有独立的存储空间,而是和所属进程中的其它线程共享一个存储空间,这使得线程间的通信远较进程简单. 多个线程的执行是并发的,也就是在逻辑上"同时",而不管是否是物理上的"同时".如果系统只有一个CPU,那么真正的"同时"是不可能的.多线程和传统的单线程

多线程及线程池学习心得

一.线程的应用与特点 多线程是程序员不可或缺的技术能力,多线程技术在各个方面都有应用,特别在性能优化上更是起到至关重要的作用.但是,如果多线程写得不好,往往会适得其反,特别是高并发时会造成阻塞.超时等现象.多线程具有以下特点:1.独立性,拥有自己独立的资源,拥有自己私有的地址空间:2.动态性,进程具有自己的生命周期和各种不同的状态:3.并发性,多个进程可以在单个处理器上并发执行,不会相互影响,并行是指同一时刻有多条指令在多个处理器上同时执行.线程是进程的组成部分,一个进程可以拥有多个线程,一个线

Android多线程编程之线程池学习篇(一)

Android多线程编程之线程池学习篇(一) 一.前言 Android应用开发中多线程编程应用比较广泛,而应用比较多的是ThreadPoolExecutor,AsyncTask,IntentService,HandlerThread,AsyncTaskLoader等,为了更详细的分析每一种实现方式,将单独成篇分析.后续篇章中可能涉及到线程池的知识,特此本篇分析为何使用线程池,如何使用线程池以及线程池的使用原理. 二.Thread Pool基础 进程代表一个运行中的程序,一个运行中的Android

线程 进程 多线程 多进程

进程和线程的主要区别在于多进程每个进程拥有独立存储空间,而多线程共享存储空间.对于单核CPU来讲,如果是阻塞操作,或者不耗时非阻塞操作,多进程/线程不会提高效率,这时候多进程/线程最有用的通常是耗时而又非阻塞的I/O操作. 打个比喻,一个人要看两部电影,可以看完一部再看另一部,也可以同时看,看一眼这个暂停,看一眼那个再暂停看回前一个,快速不停切换,你会觉得因为两部一起看所以先看完吗?理论上两部电影播放时间加起来是一样,所以看完所用时间应该一样.但是实际使用时间反而可能第一种方法快,为什么?切换是

Java 线程池学习

Reference: <创建Java线程池>[1],<Java线程:新特征-线程池>[2], <Java线程池学习>[3],<线程池ThreadPoolExecutor使用简介>[4],<Java5中的线程池实例讲解>[5],<ThreadPoolExecutor使用和思考>[6] [1]中博主自己通过ThreadGroup实现一个线程池(挺方便理解的),使用的是jdk1.4版本,Jdk1.5版本以上提供了现成的线程池. [2]中介绍

线程进程概述

进程和线程目的,提高执行效率 1,单进程单线程,主进程,主线程 2,自定义线程: 主线程 主线程 子线程 进程: 优点,同时利用多个CPU,能同时进行多个操作 缺点,耗费资源,(重新开辟内存) 线程: 优点,共享内存,IO操作时候,创造并发操作 缺点,抢占资源 进程不是 越多越好,CPU个数=等于进程个数 线程也不是越多约好,具体案例具体分析 计算机中执行任务的最小单元是:线程 IO 操作利用CPU GIL,全局解释器锁 IO密集型(不用CPU) 多线程 计算密集型(用CPU) 多进程

Linux 进程学习

------------------------------------------------------------------------------------------- ps 显示瞬间进程的状态,并不动态连续,如果想对进程进行时间控制,应该用top     -A 列出所有的行程  -w 显示加宽可以显示较多的资讯  -au 显示较详细的资讯  -aux 显示所有包含其他使用者的进程 #平时用的比较多的是 ps axu  # -e 显示所有进程 -f 显示所有进程的所有信息 -r 只

我的读书笔记(线程进程)

线程有时候可以被称为微进程或轻量级进程,它的概念和进程十分相似,是一个可以被调度的单元,并且维护自己的堆栈和上下文环境,线程是附属进程的,一个进程可以包含1个或者多个线程,并且同一进程内的多个线程共享一块内存快和资源,一个线程是一个操作系统可调度的基本单元,但同时它的调度受限于包含该线程的进程,也就是说操作系统首先决定了下一个执行的进程,进而才会调度该进程内的线程 线程和进程最大的区别在于隔离性的问题,每个进程都被单独地隔离,拥有自己的内存快,独占的资源及运行数据,一个进程的崩溃不会影响到其他进