精华内容
下载资源
问答
  • 一句话总结:父进程创建子进程时,子进程会复制父进程的内存(包括锁状态),需仔细处理。 1、死锁例子 #include #include #include #include pthread_mutex_t mutex = PTHREAD_MUTEX_...

    一句话总结:父进程创建子进程时,子进程会复制父进程的内存(包括锁状态),需仔细处理。

    1、死锁例子

    #include <stdio.h>

    #include <time.h>

    #include <pthread.h>

    #include <unistd.h>


    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


    void* doit(void* arg)

    {

    printf("pid = %d begin doit ...\n",static_cast<int>(getpid()));

    pthread_mutex_lock(&mutex);

    struct timespec ts = {2, 0};

    nanosleep(&ts, NULL);

    pthread_mutex_unlock(&mutex);

    printf("pid = %d end doit ...\n",static_cast<int>(getpid()));


    return NULL;

    }


    int main(void)

    {

    printf("pid = %d Entering main ...\n", static_cast<int>(getpid()));

    pthread_t tid;

    pthread_create(&tid, NULL, doit, NULL);

    struct timespec ts = {1, 0};

    nanosleep(&ts, NULL);

    if (fork() == 0)

    {

    doit(NULL);

    }

    pthread_join(tid, NULL);

    printf("pid = %d Exiting main ...\n",static_cast<int>(getpid()));


    return 0;

    }


    运行结果:


    通过查询进程可以发现死锁了,子进程3071无法往下执行。

    原因:父进程创建的线程调用doit()后,对mutex加了锁;此时fork了一个子进程,子进程复制父进程的内存,包括此时的mutex锁状态;父进程接着往后执行直到结束,而子进程调用了doit(),此时mutex处于加锁状态,一直等待,造成死锁。


    2、解决死锁

    如何解决上述问题呢,我们需要在fork子进程前将锁释放掉,fork之后再将父进程的锁加上。用

    int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
    pthread_atfork()在fork()之前调用,当调用fork时,内部创建子进程前在父进程中会调用prepare,内部创建子进程成功后,父进程会调用parent ,子进程会调用child。

    不过还是尽量少将多进程多线程混在一起。


    #include <stdio.h>

    #include <time.h>

    #include <pthread.h>

    #include <unistd.h>


    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


    void* doit(void* arg)

    {

    printf("pid = %d begin doit ...\n",static_cast<int>(getpid()));

    pthread_mutex_lock(&mutex);

    struct timespec ts = {2, 0};

    nanosleep(&ts, NULL);

    pthread_mutex_unlock(&mutex);

    printf("pid = %d end doit ...\n",static_cast<int>(getpid()));


    return NULL;

    }


    void prepare(void)

    {

        printf("pid = %d prepare ...\n", static_cast<int>(getpid()));

        pthread_mutex_unlock(&mutex);

    }


    void parent(void)

    {

        printf("pid = %d parent ...\n", static_cast<int>(getpid()));

        pthread_mutex_lock(&mutex);

    }


    void child(void)

    {

        printf("pid = %d child ...\n", static_cast<int>(getpid()));

    }


    int main(void)

    {

    pthread_atfork(prepare, parent, child);

    printf("pid = %d Entering main ...\n", static_cast<int>(getpid()));

    pthread_t tid;

    pthread_create(&tid, NULL, doit, NULL);

    struct timespec ts = {1, 0};

    nanosleep(&ts, NULL);

    if (fork() == 0)

    {

        doit(NULL);

    }

    pthread_join(tid, NULL);

    printf("pid = %d Exiting main ...\n",static_cast<int>(getpid()));


    return 0;

    }


    结果:






    展开全文
  • HTTPServer线程进程

    千次阅读 2014-10-10 20:43:49
      线程和进程¶ HTTPServer是SocketServer.TCPServer的一个简单子类. 它不使用多线程多进程来处理请求. 要增加多线程多进程, 可以使用SocketServer中的合适的混用类来创建一个新的类. from

    http://pymotwcn.readthedocs.org/en/latest/documents/BaseHTTPServer.html

     

    线程和进程

    HTTPServer是SocketServer.TCPServer的一个简单子类. 它不使用多线程或多进程来处理请求. 要增加多线程和多进程, 可以使用SocketServer中的合适的混用类来创建一个新的类.

    from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
    from SocketServer import ThreadingMixIn
    import threading
    
    class Handler(BaseHTTPRequestHandler):
    
        def do_GET(self):
            self.send_response(200)
            self.end_headers()
            message = threading.currentThread().getName() ## 这里threading就可以自己处理
            self.wfile.write(message)
            self.wfile.write('\n')
            return
    
    class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
        """Handle requests in a separate thread."""
    
    if __name__ == '__main__':
        server = ThreadedHTTPServer(('localhost', 8080), Handler)
        print 'Starting server, use <Ctrl-C> to stop'
        server.serve_forever()
    

    每次当一个请求过来的时候, 一个新的线程或进程会被创建来处理它:

    $ curl http://localhost:8080/
    Thread-1
    $ curl http://localhost:8080/
    Thread-2
    $ curl http://localhost:8080/
    Thread-3

    如果把上面的ThreadingMixIn换成ForkingMixIn, 也可以获得类似的结果, 但是后者是使用了独立的进程而不是线程.

    展开全文
  • 1)缩进四个空格,空格与Tab不能混用 2)行长80,防止单行逻辑复杂 2、import: 1)不能用 from xxx import * 2) 顺序:标准库 第三方库 自定义库 3)单行不要import 个库 4) 模块内用不到的不要import 3、空格 1...

    1.PEP8编码规范,以及开发中的一些惯例和建议

    1、代码编排:
    1)缩进四个空格,空格与Tab不能混用
    2)行长80,防止单行逻辑复杂
    2、import:
    1)不能用 from xxx import *
    2) 顺序:标准库
    第三方库
    自定义库
    3)单行不要import 多个库
    4) 模块内用不到的不要import
    3、空格
    1):, ; 后面跟一个空格,前面五空格(行尾分号后五空格)
    2)二元操作符前后各一个空格,包括:
    1.数学运算符 + - * / // = & |
    2.比较运算符 == != < > <= >= is not in
    3.逻辑运算符 and or not
    4.位运算符 & | ^ << >>
    5.当=用于指示关键字参数或默认参数值时,不要在其两侧使用空格
    4、适当添加空行:
    函数间:顶级函数间空2行,类方法之间空1行
    函数内:同一函数内逻辑块之间空1行
    文件结尾:留一个空行
    5、语义明确、直白:
    not xx in yy VS xx is not in yy
    not a is b VS a is not b

    二、函数闭包

    引用了自由变量的函数即是一个闭包,这个被引用的自由变量和这个函数一同存在

    def foo():
        l = []
        def bar(i):
            l.append(i)
            return l
        return bar
    if  __name__=="__main__":
        f1 = foo()
        f2 = foo()
        f3 = foo()
        print(f1(1))
        print(f2(2))
        print(f3(3))
        """
        [1]
    	[2]
    	[3]
        """
    

    三、装饰器

    1、最简装饰器

    def deco(func):
        #print(func)
        #print('lalala')
        def warp():
            print('成功')
            return func()
        return warp
    @deco
    def A():
        print('Joker')
    @deco
    def B():
        print('Joker2')
    A()
    B()
    """
    成功
    Joker
    Joker2
    A()-->deco-->func:A-->return warp:warp()-->'hahaha'
    """
    

    2、函数体加参数

     def deco(func):
        #print(func)
        #print('lalala')
        def warp(n):
            print('成功')
            n = 'ok'
            return func(n)
        return warp
    @deco
    def A(name):
        print(name)
    A('joker')
    """
    成功
    ok
    """
    
     def deco(func):
        def warp(n,n1):
            print('成功')
            n = 'OK'
            return func(n,n1)
        return warp
    
    @deco
    def A(name,name2): 
        print(name)
        print(name2)
    A('joker','faker')
    
    """
    OK
    faker
    """
    

    案例:
    1、输入两个数字,装饰器求和,本函数打印这两个数字的和

    def deco(func):
        def add(a,b):
            he = a + b
            return  func(he,b)
        return add
    @deco
    def A(name,name1):
        print(name)
    A(10,20)
    """
    30
    """
    

    2、垃圾验证码:无论输入啥验证码,都返回验证码错误,前提在装饰器的情况下。如果不使用,则正确就打印正确

    import random
    def deco(func):
        def yan(n1,n2):
            n1 = -1
            return func(n1,n2)
        return yan
    @deco
    def A(n1,n2):
        if n1 == n2:
            print('正确')
        else:
            print('错误')
    
    num = random.randrange(1000,9999)
    print('验证码:%d'%num)
    num2 = int(input('请输入验证码'))
    A(num,num2)
    """
    """
    验证码:5552                 验证码:7351
    请输入验证码5556             请输入验证码7351
    错误                         错误
    """
    
    import random
    def deco2(parms):
        def deco(func): 
            def warp(n1,n2):
                if parms:
                    n1 = -1
                return func(n1,n2)
            return warp
        return deco
    
    @deco2(False)  (True则走装饰器)
    def A(n1,n2):
        if n1 == n2:
            print('验证码输入正确')
        else:
            print('验证码输入错误')
    
    num = random.randrange(1000,9999)
    print('验证码是%d'%num) 
    num2 = int(input('>>'))        
    A(num,num2)
    

    3、检测某个时间段内(5秒)ip访问次数,如果ip访问次数超过10次,则返回404

    import time
    TIME1 = 0
    TIME2 = 0
    
    def check_ip(func):
        def warp (*args,**kwargs):
            if (round(abs(TIME2 - TIME1),2)) < 0.5:
                print('404')
            else:
                return func(*args,**kwargs)
        return warp
    
    @check_ip
    def A(ip):
        print('登录页面成功')
    #模拟请求
    for _ in range(50):
        ip = '127.0.0.1'
        TIME1 = time.time()
        A(ip)
    
        TIME2 = time.time()
        time.sleep(0.1)
        """
        登录页面成功
        404
        404
        404
        404
        """
    

    四.进程和线程

    概念
    进程就是操作系统中执行的一个程序,操作系统以进程为单位分配存储空间,每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据,操作系统管理所有进程的执行,为它们合理的分配资源
    python中的多进程

    简单的多进程

    import multiprocessing
    
    def A():
        print('Hello')
    
    if __name__ == "__main__":
        #创建进程
        p = multiprocessing.Process(target = A, args = ())
        p.start()  #启动进程
        p.join()
        print('Over')
    """
    Hello
    Over
    """
    

    多进程

    import multiprocessing
    import os
    
    def A(name):
        print(os.getpid())
        print(name)
    
    if __name__ == "__main__":
        #创建进程
        p1 = multiprocessing.Process(target = A, args = ('sdf1',))
        p2 = multiprocessing.Process(target = A, args = ('sdf2',))
        p1.start()
        p2.start()  #启动进程
        p2.join()
        p2.join()
        print('OK')
        """
        20920
    	sdf1
    	19444
    	sdf2
    	OK
        """
    
    展开全文
  • 1)缩进四个空格,空格与Tab不能混用 2)行长80,防止单行逻辑复杂 2、import: 1)不能用 from xxx import * 2)顺序:标准库、第三方库、自定义库 3)单行不要import个库 4)模块内用不到的不要去import 3、空格...

    python进阶

    一、编码规范

    1、代码编排:
    1)缩进四个空格,空格与Tab不能混用
    2)行长80,防止单行逻辑复杂
    2、import:
    1)不能用 from xxx import *
    2)顺序:标准库、第三方库、自定义库
    3)单行不要import多个库
    4)模块内用不到的不要去import
    3、空格
    1)标点符号后面跟一个空格,前面不要空格(行尾分号后无空格)
    2)运算符前后各一个空格
    3)当 = 用于指示关键字参数或默认值时,两侧无空格
    4、适当添加空行
    1)函数间:顶级函数间空两行,类的方法之间空1行
    2)同一函数内的逻辑块之间空一行
    3)文件结尾:留一个空行(Unix中\n是文件结束符)
    5、注释
    1)忌:逐行添加注释、没有一个注释
    2)行内注释:单行逻辑过于复杂时添加
    3)块注释:一段逻辑开始时添加
    4)引入外来算法或者配置时需在注释中添加原链接,标明出处
    5)函数和类尽可能添加docstring
    6、命名
    1)不要用单字母的变量名
    2)包名、模块名、函数名、方法名小写,单词间用下划线连接
    3)类名、异常名使用CapWords(首字母大写)的方式,异常名结尾加Error或Warning后缀
    4)全局变量尽量使用大写,一组同类型的全局变量要加统一前缀,单词用下滑线连接
    7、字符串拼接尽量使用join
    速度快,内存消耗小
    8、语意明确、直白
    9、程序的构建
    1)一个函数只能做一件事,并把这件事做好
    2)大的功能用小的函数之间的灵活组合来完成
    3)避免编写庞大的程序
    10、函数名必须有动词,最好是do_something形式,或somebody_do_something句式
    11、自定义的变量名、函数名不要与标准库中的名字冲突
    12、格式化
    Alt+Shift+f

    二、函数闭包

    引用了自由变量的函数即是一个闭包,这个被引用的自由变量和这个函数一同存在。

    def foo():
        l = []
        def bar(i):
            l.append(i)
            return l
        return bar
    
    if __name__ == "__main__":
        f1 = foo()
        print(f1)
    
    #<function foo.<locals>.bar at 0x000000C17DF41378>
    
    def foo():
        l = []
        def bar(i):
            l.append(i)
            return l
        return bar
    
    if __name__ == "__main__":
        f1 = foo()
        f2 = foo()
        f3 = foo()
        print(f1(1))
        print(f2(2))
        print(f3(3))
    """
    [1]
    [2]
    [3]
    """
    
    def foo():
        l = []
        def bar(i):
            l.append(i)
            return l
        return bar
    
    if __name__ == "__main__":
        f1 = foo()
        f2 = foo()
        print(f1(1))
        print(f2(2))
        print(f2(3))
    """
    [1]
    [2]
    [2, 3]
    """
    

    三、装饰器

    1、最简装饰器

    def deco(func):
        def warp():
            print('hahaha')
        return warp
    
    @deco
    def A():
        print('joker')
    A() 
    
    #hahaha
    

    逻辑:A() -->deco --> func:A --> return warp:warp() --> “hahaha”

    def deco(func):
        def warp():
            print('hahaha')
            func()
        return warp
    
    @deco
    def A(): #不带参
        return'joker'
    print(A()) #被warp捕获
    
    """
    hahaha
    None
    """
    
    def deco(func):
        def warp():
            print('hahaha')
            return func()
        return warp
    
    @deco
    def A():
        print('hahaha')
        return'joker'
    print(A())
    """
    hahaha
    hahaha
    joker
    """
    

    2、函数体加参数

    def deco(func):
        def warp(n):
            print('hahaha')
            return func(n)
        return warp
    
    @deco
    def A(name):
        print(name)
    A('joker')
    """
    hahaha
    joker
    """
    
    def deco(func):
        def warp(n):
            print('hahaha')
            n = 'OK'
            return func(n)
        return warp
    
    @deco
    def A(name):  (参数等同于作废)
        print(name)
    A('joker')
    
    """
    hahaha
    OK
    """
    
    def deco(func):
        def warp(n,n1):
            print('hahaha')
            n = 'OK'
            return func(n,n1)
        return warp
    
    @deco
    def A(name,name2): 
        print(name)
        print(name2)
    A('joker','faker')
    
    """
    OK
    faker
    """
    

    练习
    1)输入两个数字,装饰器的作用是求这两个数字的和,本函数的作用是打印这两个数字的和

    def deco(func):
        def warp(n,n1):
            sum_ = n + n1
            return func(sum_,n1)
        return warp
    
    @deco
    def A(name,name2): 
        print(name)
    A(10,20)
    #30
    

    2)无敌验证码:无论输入什么都返回错误

    import random
    def deco(func):
        def warp(n1,n2): 
            n1 = -1
            return func(n1,n2)
        return warp
    
    @deco
    def A(n1,n2):
        if n1 == n2:
            print('验证码输入正确')
        else:
            print('验证码输入错误')
    
    num = random.randrange(1000,9999)
    print('验证码是%d'%num) 
    num2 = int(input('>>'))        
    A(num,num2)
    
    """
    验证码是9833
    >>9833
    验证码输入错误
    """
    

    3、装饰器传参

    import random
    def deco2(parms):
        def deco(func): 
            def warp(n1,n2):
                if parms:
                    n1 = -1
                return func(n1,n2)
            return warp
        return deco
    
    @deco2(False)  (True则走装饰器)
    def A(n1,n2):
        if n1 == n2:
            print('验证码输入正确')
        else:
            print('验证码输入错误')
    
    num = random.randrange(1000,9999)
    print('验证码是%d'%num) 
    num2 = int(input('>>'))        
    A(num,num2)
    

    4、不定长参数
    1)*args

    import random
    def deco2(parms):
        def deco(func): 
            def warp(*args,**kwargs):
                args = list(args)
                if parms:
                    args[0] = -1
                return func(*args,**kwargs)
            return warp
        return deco
    
    @deco2(True)  
    def A(n1,n2):
        if n1 == n2:
            print('验证码输入正确')
        else:
            print('验证码输入错误')
    
    num = random.randrange(1000,9999)
    print('验证码是%d'%num) 
    num2 = int(input('>>'))        
    A(num,num2)
    

    2)**kwargs

    import random
    def deco2(parms):
        def deco(func): 
            def warp(*args,**kwargs):
                if parms:
                    kwargs['n1'] = -1
                return func(*args,**kwargs)
            return warp
        return deco
    
    @deco2(True)  
    def A(n1,n2):
        if n1 == n2:
            print('验证码输入正确')
        else:
            print('验证码输入错误')
    
    num = random.randrange(1000,9999)
    print('验证码是%d'%num) 
    num2 = int(input('>>'))        
    A(n1 = num,n2 = num2)
    

    练习:
    检测某个时间段内(5秒)ip访问次数,超过十次则返回404

    import time
    
    TIME1 = 0
    TIME2 = 0
    
    def check_ip(func):
        def warp(*args,**kwargs):
            if round(abs(TIME2 - TIME1),3) < 0.5:
                print('404')
            else:
                return func(*args,**kwargs)
        return warp
    
    @check_ip
    def A(ip):
        print('进入网页成功')
    
    #模拟请求
    for _ in range(50):
        ip = '127.0.0.1'
        TIME1 = time.time()
        A(ip)
        TIME2 = time.time
        time.sleep(1)
    

    进程和线程

    一、概念

    1、进程:
    操作系统中执行的一个程序,操作系统以进程为单位分配存储空间,每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据,操作系统管理所有进程的执行,为它们合理的分配资源。
    2、线程
    一个进程还可以拥有多个并发的执行线索,简单的说就是拥有多个可以获得CPU调度的执行单元,这就是线程

    二、多进程

    1、最简单的进程

    import multiprocessing
    
    def A():
        print('Hello')
    
    if __name__ == "__main__":
        #创建进程
        p = multiprocessing.Process(target = A, args = ())
        p.start()  #启动进程
        p.join()
        print('Over')
    
    #Hello
    #Over
    

    2、多进程

    import multiprocessing
    import os
    
    def A(name):
        print(os.getpid())
        print(name)
    
    if __name__ == "__main__":
        #创建进程
        p1 = multiprocessing.Process(target = A, args = ('sdf1',))
        p2 = multiprocessing.Process(target = A, args = ('sdf2',))
        p1.start()
        p2.start()  #启动进程
        p2.join()
        p2.join()
        print('OK')
    
    """
    sdf1
    13068
    sdf2
    OK
    """
    

    如果程序中的代码只能按顺序一点点的往下执行,那么即使执行两个毫不相关的下载任务,也需要先等待一个文件下载完成后才能开始下一个下载任务,这并不合理也没有效率。接下来我们使用多进程的方式将两个下载任务放到不同的进程中

    展开全文
  • 缩进4个空格,禁止空格与Tab混用 行长80:防止单行逻辑过于复杂 2.import 不要使用from xxx import * 3.顺序: 标准库 第三方库 自定义库 4.单行不要import个库 模块内用不到的不要去import 5.空格 :,;后面跟一...
  • 1 线程共享和非共享 1.1 线程共享资源 ...但不建议信号与线程混用,难度很大。 3)当前工作目录。物理内存地址相同,所以工作目录相同。因为工作目录的物理地址是唯一的。只有物理内存地址相同才能
  • python线程同步机制

    2018-03-08 04:37:30
    多进程中,每一个进程都拷贝了一份数据,而多线程的各个线程则共享相同的数据。这使多线程占用的资源更少,但是资源混用会导致一些错误,我们来看下面这个例子 import threadingimport timez...
  • linux下编程处理并行任务时,可以采用多进程模块(fork)或者多线程模型(pthread)。有时候还会采用混合的模式。 当混合使用两者的时候,可能存在一些问题。   一种情况是: 进程创建了一些线程,然后执行了fork。...
  • Java进程笔记

    2020-07-24 22:37:32
    多线程是程序的一个执行体 程序,软件,进程,线程,协程几个概念有一定联系 程序,软件有时可以混用,细分的话程序特指源程序,是软件运行的蓝图,是一个静态的概念。进程是软件的一次执行过程,它包括了代码,数据...
  • Unix下fork与pthread混用的问题

    千次阅读 2015-10-16 11:27:26
    (来自云风的Blog)  在POSIX标准中,fork 的行为是这样的:复制整个用户空间的数据(通常使用copy-on-write的策略,所以可以实现的速度很快)以及所有系统... 我之前从未写过多进程多线程程序,不过公司里有
  • python搭建http服务器

    千次阅读 2018-01-16 15:14:56
    转自:tycoon1988的... 线程和进程 ... 它不使用多线程多进程来处理请求. 要增加多线程多进程, 可以使用SocketServer中的合适的混用类来创建一个新的类. from BaseHTTPServer import HTTPServer, Base
  • 我在修改其中代码的时候没有考虑到多进程(multiprocessing)与多线程(threading)的区别,所以代码中有混用的情况,请注意这个情况,在此不做仔细区分。 下面多进程/多线程客户端的代码是相同的,可以多建几个文件只...
  • pathon第五天

    2019-08-21 19:20:05
    进阶、进程线程 pathon进阶 一.编码规范 1.代码编排 1)缩进四个空格,空格与Tab不能混用 2)行长80,防止单行逻辑复杂 2.import 1).不能用 from xxx import * 2).顺序:标准库、第三方库、自定义库 3)单行不要...
  • python cookbook(第3版)

    2016-01-06 22:24:38
    15.8 C和Python中的线程混用 15.9 用WSIG包装C代码 15.10 用Cython包装C代码 15.11 用Cython写高性能的数组操作 15.12 将函数指针转换为可调用对象 15.13 传递NULL结尾的字符串给C函数库 15.14 传递Unicode...
  • javaSE代码实例

    2016-06-21 22:30:18
    第16章 多线程——Java中的并发协作 343 16.1 线程的基本知识 343 16.1.1 多线程编程的意义 343 16.1.2 定义自己的线程 344 16.1.3 创建线程对象 345 16.1.4 启动线程 347 16.1.5 同时使用多个线程 ...
  • linux服务器性能调整.

    热门讨论 2011-05-11 21:50:48
    8.5 对称多线程 155 8.6 Linux 2.6内核调度器 155 8.7 负载平衡 156 8.8 调度器的可调参数 157 8.8.1 *CHILD_PENALTY 157 8.8.2 *CREDIT_LIMIT 157 8.8.3 *EXIT_WEIGHT 157 8.8.4 *INTERACTIVE_DELTA 157 8.8.5 *MAX...
  • 使进程线程创建时处于挂起状态(类似于被调试器加载,因为 据网友反馈说部分杀毒软件的内存扫描对于OLLYDBG加载的程序 起作用,而对于MYCCL、multiCCL、CCL等的加载不起作用)。 dll的加载没改(因为目前还没...
  • multiCCL_f

    热门讨论 2010-10-19 15:49:46
    未能生成完整的模板,导致很使用者第一次使用时无所适从, 2.将内存定位的一个容易引起误解的“判断……”改为“将判断……” (以上两处BUG感谢网友woaicomputer等的反馈) 3.增加了定位注入数据块的特征码的...
  • 第4章 服务器进程和ASP Server对象 98 4.1 动态页中服务器端的处理 98 4.2 服务器端的包含指令 100 4.2.1 不可思议的ASP #include指令 100 4.2.2 服务器端包含指令概要 102 4.2.3 服务器端包含指令的例子 104 ...
  • 第4章 服务器进程和ASP Server对象 98 4.1 动态页中服务器端的处理 98 4.2 服务器端的包含指令 100 4.2.1 不可思议的ASP #include指令 100 4.2.2 服务器端包含指令概要 102 4.2.3 服务器端包含指令的例子 104 ...

空空如也

空空如也

1 2
收藏数 22
精华内容 8
关键字:

多进程多线程混用