精华内容
下载资源
问答
  • linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。 对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。 其中,参数 fd 表示文件描述...
  • Python多线程读写文件加锁

    千次阅读 2018-11-16 10:11:03
    Python的多线程在io方面比单线程...在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。 对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这...

    Python的多线程在io方面比单线程还是有优势,但是在多线程开发时,少不了对文件的读写操作。在管理多个线程对同一文件的读写操作时,就少不了文件锁了。

    使用fcntl

    在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。

    对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。

    其中,参数 fd 表示文件描述符;参数 operation 指定要进行的锁操作,该参数的取值有如下几种:

    • LOCK_SH:表示要创建一个共享锁,在任意时间内,一个文件的共享锁可以被多个进程拥有
    • LOCK_EX:表示创建一个排他锁,在任意时间内,一个文件的排他锁只能被一个进程拥有
    • LOCK_UN:表示删除该进程创建的锁
    • LOCK_MAND:它主要是用于共享模式强制锁,它可以与 LOCK_READ 或者 LOCK_WRITE联合起来使用,从而表示是否允许并发的读操作或者并发的写操作

    demo

    import fcntl
    import threading
    import time
    
    
    def writetoTxt(txtFile):
        id = threading.currentThread().getName()
        with open(txtFile, 'a') as f:
            fcntl.flock(f.fileno(), fcntl.LOCK_EX) #加锁
            print "{0} acquire lock".format(id)
            f.write("write from {0} \r\n".format(id))
            time.sleep(3)
        # 在with块外,文件关闭,自动解锁
        print "{0} exit".format(id)
    
    
    for i in range(5):
        myThread = threading.Thread(target=writetoTxt, args=("test.txt",))
        myThread.start()
    

    代码运行期间,控制台将依次打印哪个线程获得了锁,在对文件进行读写。

    Thread-1 acquire lock
    Thread-1 exit
    Thread-2 acquire lock
    Thread-2 exit
    Thread-3 acquire lock
    Thread-3 exit
    Thread-5 acquire lock
    Thread-5 exit
    Thread-4 acquire lock
    Thread-4 exit

    小结

    通过调用

    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
    

    对文件加锁,如果有其他线程尝试对test文件加锁,会被阻塞。

    当线程执行完毕的时候,锁会自动释放。或者也可以采取主动的方式解锁:调用

    fcntl.flock(f.fileno(),fcntl.LOCK_UN)
    

    函数, 对文件test解锁

    使用线程锁

    当多个线程共享一个数据的时候,必须要进行同步的控制,不然会出现不可预期的结果,即 “线程不安全”

    线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁。
    互斥锁为资源引入一个状态:锁定/非锁定。
    某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;
    直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。
    互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。
    

    threading模块中定义了Lock类,可以方便的处理锁定:

    #创建锁
    mutex = threading.Lock()
    #锁定
    mutex.acquire([timeout])
    #解锁
    mutex.release()
    

    Demo

    使用互斥锁实现上面的例子的代码如下:

    import threading
    import time
    
    def writetoTxt(txtFile):
        id = threading.currentThread().getName()
        mutex.acquire(10)
        with open(txtFile, 'a') as f:
            print "Thread {0} acquire lock".format(id)
            f.write("write from thread {0} \r\n".format(id))
            time.sleep(3)
        mutex.release()
        print "Thread {0} exit".format(id)
    
    
    mutex = threading.Lock()
    
    for i in range(5):
        myThread = threading.Thread(target=writetoTxt, args=("test.txt",))
        myThread.start()
    

    (上述代码本质上是一个顺序执行的单线程)

    结果:

    Thread Thread-1 acquire lock
    Thread Thread-1 exit
    Thread Thread-2 acquire lock
    Thread Thread-2 exit
    Thread Thread-3 acquire lock
    Thread Thread-3 exit
    Thread Thread-4 acquire lock
    Thread Thread-4 exit
    Thread Thread-5 acquire lock
    Thread Thread-5 exit
    

    小结

    当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“同步阻塞”。
    直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。

     

    展开全文
  • 使用fcntl在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。其中...

    python的多线程在io方面比单线程还是有优势,但是在多线程开发时,少不了对文件的读写操作。在管理多个线程对同一文件的读写操作时,就少不了文件锁了。

    使用fcntl

    在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。

    对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。

    其中,参数 fd 表示文件描述符;参数 operation 指定要进行的锁操作,该参数的取值有如下几种:

    LOCK_SH:表示要创建一个共享锁,在任意时间内,一个文件的共享锁可以被多个进程拥有

    LOCK_EX:表示创建一个排他锁,在任意时间内,一个文件的排他锁只能被一个进程拥有

    LOCK_UN:表示删除该进程创建的锁

    LOCK_MAND:它主要是用于共享模式强制锁,它可以与 LOCK_READ 或者 LOCK_WRITE联合起来使用,从而表示是否允许并发的读操作或者并发的写操作

    demo import fcntl

    import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    with open(txtFile, 'a') as f:

    fcntl.flock(f.fileno(), fcntl.LOCK_EX) #加锁

    print "{0} acquire lock".format(id)

    f.write("write from {0} \r\n".format(id))

    time.sleep(3)

    # 在with块外,文件关闭,自动解锁

    print "{0} exit".format(id)

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    代码运行期间,控制台将依次打印哪个线程获得了锁,在对文件进行读写。 Thread-1 acquire lock

    Thread-1 exit

    Thread-2 acquire lock

    Thread-2 exit

    Thread-3 acquire lock

    Thread-3 exit

    Thread-5 acquire lock

    Thread-5 exit

    Thread-4 acquire lock

    Thread-4 exit

    小结

    通过调用 fcntl.flock(f.fileno(), fcntl.LOCK_EX)

    对文件加锁,如果有其他线程尝试对test文件加锁,会被阻塞。

    当线程执行完毕的时候,锁会自动释放。或者也可以采取主动的方式解锁:调用 fcntl.flock(f.fileno(),fcntl.LOCK_UN)

    函数, 对文件test解锁

    使用线程锁

    当多个线程共享一个数据的时候,必须要进行同步的控制,不然会出现不可预期的结果,即 “线程不安全” 线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁。

    互斥锁为资源引入一个状态:锁定/非锁定。

    某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;

    直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。

    互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。

    threading模块中定义了Lock类,可以方便的处理锁定: #创建锁

    mutex = threading.Lock()

    #锁定

    mutex.acquire([timeout])

    #解锁

    mutex.release()

    Demo

    使用互斥锁实现上面的例子的代码如下: import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    mutex.acquire(10)

    with open(txtFile, 'a') as f:

    print "Thread {0} acquire lock".format(id)

    f.write("write from thread {0} \r\n".format(id))

    time.sleep(3)

    mutex.release()

    print "Thread {0} exit".format(id)

    mutex = threading.Lock()

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    (上述代码本质上是一个顺序执行的单线程)

    结果: Thread Thread-1 acquire lock

    Thread Thread-1 exit

    Thread Thread-2 acquire lock

    Thread Thread-2 exit

    Thread Thread-3 acquire lock

    Thread Thread-3 exit

    Thread Thread-4 acquire lock

    Thread Thread-4 exit

    Thread Thread-5 acquire lock

    Thread Thread-5 exit

    小结

    当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“同步阻塞”。

    直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。

    以上这篇对Python多线程读写文件加锁的实例详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持聚米学院。

    展开全文
  • 使用fcntl在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。其中...

    Python的多线程在io方面比单线程还是有优势,但是在多线程开发时,少不了对文件的读写操作。在管理多个线程对同一文件的读写操作时,就少不了文件锁了。

    使用fcntl

    在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。

    对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。

    其中,参数 fd 表示文件描述符;参数 operation 指定要进行的锁操作,该参数的取值有如下几种:

    LOCK_SH:表示要创建一个共享锁,在任意时间内,一个文件的共享锁可以被多个进程拥有

    LOCK_EX:表示创建一个排他锁,在任意时间内,一个文件的排他锁只能被一个进程拥有

    LOCK_UN:表示删除该进程创建的锁

    LOCK_MAND:它主要是用于共享模式强制锁,它可以与 LOCK_READ 或者 LOCK_WRITE联合起来使用,从而表示是否允许并发的读操作或者并发的写操作

    demo

    import fcntl

    import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    with open(txtFile, 'a') as f:

    fcntl.flock(f.fileno(), fcntl.LOCK_EX) #加锁

    print "{0} acquire lock".format(id)

    f.write("write from {0} \r\n".format(id))

    time.sleep(3)

    # 在with块外,文件关闭,自动解锁

    print "{0} exit".format(id)

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    代码运行期间,控制台将依次打印哪个线程获得了锁,在对文件进行读写。

    Thread-1 acquire lock

    Thread-1 exit

    Thread-2 acquire lock

    Thread-2 exit

    Thread-3 acquire lock

    Thread-3 exit

    Thread-5 acquire lock

    Thread-5 exit

    Thread-4 acquire lock

    Thread-4 exit

    小结

    通过调用

    fcntl.flock(f.fileno(), fcntl.LOCK_EX)

    对文件加锁,如果有其他线程尝试对test文件加锁,会被阻塞。

    当线程执行完毕的时候,锁会自动释放。或者也可以采取主动的方式解锁:调用

    fcntl.flock(f.fileno(),fcntl.LOCK_UN)

    函数, 对文件test解锁

    使用线程锁

    当多个线程共享一个数据的时候,必须要进行同步的控制,不然会出现不可预期的结果,即 “线程不安全”

    线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁。

    互斥锁为资源引入一个状态:锁定/非锁定。

    某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;

    直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。

    互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。

    threading模块中定义了Lock类,可以方便的处理锁定:

    #创建锁

    mutex = threading.Lock()

    #锁定

    mutex.acquire([timeout])

    #解锁

    mutex.release()

    Demo

    使用互斥锁实现上面的例子的代码如下:

    import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    mutex.acquire(10)

    with open(txtFile, 'a') as f:

    print "Thread {0} acquire lock".format(id)

    f.write("write from thread {0} \r\n".format(id))

    time.sleep(3)

    mutex.release()

    print "Thread {0} exit".format(id)

    mutex = threading.Lock()

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    (上述代码本质上是一个顺序执行的单线程)

    结果:

    Thread Thread-1 acquire lock

    Thread Thread-1 exit

    Thread Thread-2 acquire lock

    Thread Thread-2 exit

    Thread Thread-3 acquire lock

    Thread Thread-3 exit

    Thread Thread-4 acquire lock

    Thread Thread-4 exit

    Thread Thread-5 acquire lock

    Thread Thread-5 exit

    小结

    当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“同步阻塞”。

    直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。

    以上这篇对Python多线程读写文件加锁的实例详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 使用fcntl在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。其中...

    Python的多线程在io方面比单线程还是有优势,但是在多线程开发时,少不了对文件的读写操作。在管理多个线程对同一文件的读写操作时,就少不了文件锁了。

    使用fcntl

    在linux下,python的标准库有现成的文件锁,来自于fcntl模块。这个模块提供了unix系统fcntl()和ioctl()的接口。

    对于文件锁的操作,主要需要使用 fcntl.flock(fd, operation)这个函数。

    其中,参数 fd 表示文件描述符;参数 operation 指定要进行的锁操作,该参数的取值有如下几种:

    LOCK_SH:表示要创建一个共享锁,在任意时间内,一个文件的共享锁可以被多个进程拥有

    LOCK_EX:表示创建一个排他锁,在任意时间内,一个文件的排他锁只能被一个进程拥有

    LOCK_UN:表示删除该进程创建的锁

    LOCK_MAND:它主要是用于共享模式强制锁,它可以与 LOCK_READ 或者 LOCK_WRITE联合起来使用,从而表示是否允许并发的读操作或者并发的写操作

    demo

    import fcntl

    import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    with open(txtFile, 'a') as f:

    fcntl.flock(f.fileno(), fcntl.LOCK_EX) #加锁

    print "{0} acquire lock".format(id)

    f.write("write from {0} \r\n".format(id))

    time.sleep(3)

    # 在with块外,文件关闭,自动解锁

    print "{0} exit".format(id)

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    代码运行期间,控制台将依次打印哪个线程获得了锁,在对文件进行读写。

    Thread-1 acquire lock

    Thread-1 exit

    Thread-2 acquire lock

    Thread-2 exit

    Thread-3 acquire lock

    Thread-3 exit

    Thread-5 acquire lock

    Thread-5 exit

    Thread-4 acquire lock

    Thread-4 exit

    小结

    通过调用

    fcntl.flock(f.fileno(), fcntl.LOCK_EX)

    对文件加锁,如果有其他线程尝试对test文件加锁,会被阻塞。

    当线程执行完毕的时候,锁会自动释放。或者也可以采取主动的方式解锁:调用

    fcntl.flock(f.fileno(),fcntl.LOCK_UN)

    函数, 对文件test解锁

    使用线程锁

    当多个线程共享一个数据的时候,必须要进行同步的控制,不然会出现不可预期的结果,即 “线程不安全”

    线程同步能够保证多个线程安全访问竞争资源,最简单的同步机制是引入互斥锁。

    互斥锁为资源引入一个状态:锁定/非锁定。

    某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;

    直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。

    互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。

    threading模块中定义了Lock类,可以方便的处理锁定:

    #创建锁

    mutex = threading.Lock()

    #锁定

    mutex.acquire([timeout])

    #解锁

    mutex.release()

    Demo

    使用互斥锁实现上面的例子的代码如下:

    import threading

    import time

    def writetoTxt(txtFile):

    id = threading.currentThread().getName()

    mutex.acquire(10)

    with open(txtFile, 'a') as f:

    print "Thread {0} acquire lock".format(id)

    f.write("write from thread {0} \r\n".format(id))

    time.sleep(3)

    mutex.release()

    print "Thread {0} exit".format(id)

    mutex = threading.Lock()

    for i in range(5):

    myThread = threading.Thread(target=writetoTxt, args=("test.txt",))

    myThread.start()

    (上述代码本质上是一个顺序执行的单线程)

    结果:

    Thread Thread-1 acquire lock

    Thread Thread-1 exit

    Thread Thread-2 acquire lock

    Thread Thread-2 exit

    Thread Thread-3 acquire lock

    Thread Thread-3 exit

    Thread Thread-4 acquire lock

    Thread Thread-4 exit

    Thread Thread-5 acquire lock

    Thread Thread-5 exit

    小结

    当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为“blocked”状态,称为“同步阻塞”。

    直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。

    以上这篇对Python多线程读写文件加锁的实例详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持。

    展开全文
  • LINUX多线程读写同一个文件 加锁

    千次阅读 2016-07-26 17:10:18
    当有多个工作线程要同时对一个文件进行写操作时,如果不对该文件进行加锁就可能会因误操作而引起一系列的问题。  解决这个问题有多种方法。我们这里考虑使用文件锁来对文件进行保护,因为这个方法简单易行。具体...
  • Linux下C/C++给文件加锁

    千次阅读 2019-12-21 23:14:16
    本文主要讲述Linux下如何在C/C++程序中给文件加锁,防止多个进程并发读写同一个文件导致文件内容不一致,使用fcntl()函数,这是一个POSIX函数。 一 为何需要文件锁 假设有一个菜谱文件,其内容是今天需要买的菜,...
  • Linux 多进程读写文件 文件锁

    千次阅读 2015-07-07 14:30:33
    目前遇到一个问题:多个进程对同一个文件进行写操作,如何避免冲突。研究了一下,做个小结。   对于多进程写文件,主要有以下两种处理方式: ...1.类似于Linux日志文件服务 ...对当前读写文件进行加锁处理,简单说
  • linux 中的文件

    2016-07-05 21:33:37
    Linux运行多个进程同时对一文件进行读写,虽然每一个read和write都是原子操作,但内核并没有在两个读写操作之间加以同步。...对文件加锁有两种:文件锁和记录锁。文件锁(文件锁定)用来锁定整个文
  • linux文件

    2012-06-04 15:25:38
    特性:  读写锁也叫共享——排他锁,因为有3种状态, 所以可以有更高的并行性。... 当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞。 ? 当读写锁在读加锁状态时,
  • Linux C 文件锁的操作

    2017-12-06 23:55:53
    文件锁的类型 <br> 1 读锁 共享锁,如果A进程对文件的某区域加了读锁,B...当多个进程同时对一个文件进行读写操作时,为确保文件的完整和一致性,这几个进程要加锁同步。<br>当进程开始读取文件的某个区...
  • 思考:java多线程同时写一个文件第一种情况是:一个线程A有对文件加锁,另一个线程B没对文件加锁在windows7环境下:(持有锁的可以写文件成功)。在linux centos 6.3环境下:(都可以写文件成功,表现为数据交叉写入)第...
  • Linux C/C++多线程同步(互斥量,死锁,读写锁,条件变量,信号量,文件锁)1. 线程同步的一些概念1.1 同步的概念1.2 什么是线程同步1.3 多线程出现数据混乱(数据竞争)的原因2. 互斥量mutex2.1 mutex相关的函数和...
  • 在多进程下文件读写是共享的,所以会 ...对文件加锁 判定一个文件是否存在锁 函数说明: int fcntl( int fd,//被加锁的文件描述符号 int cmd,//锁的操作方式:F_SETLK(已经加锁,异常返回) F_UNLK F
  • 文件锁文件锁的作用多进程读写文件写与写应该互斥读与写也应该是互斥的情况一情况二读与读共享文件锁读锁、写锁之间关系读锁和读锁共享读锁与写锁互斥写锁与写锁互斥文件锁的加锁方式对整个文件内容加锁对整个文件...
  • 1. perl,flock加锁。java也能加锁。 2. 先创建文件并打开,才能加锁(写打开?)。 3. 可以用于判断进程是否一直在运行(用另一进程判断),如果锁...6. 为了避免对同一文件读写冲突,在写的时候可以写入另一个文...
  • 3.进程可以通过系统调用对文件加锁,从而实现对文件内容的保护 4. 任何一个进程删除该文件时,另外一个进程不会立即出现读写失败 5.两个进程可以分别读取文件的不同部分而不会相互影响 6.一...
  • 3.进程可以通过系统调用对文件加锁,从而实现对文件内容的保护 4.任何一个进程删除该文件时,另外一个进程不会立即出现读写失败 5.两个进程可以分别读取文件的不同部分而不会相互影响 6.一个进程对文件长度和内容的...
  • 程序启动的时候打开某个锁文件并对该文件加锁,退出程序时解锁。 如果无法正常加锁,则说明程序已经在内存中运行了,当前线程return即可。 代码实现 首先,先以创建+可读写模式打开锁文件temp.lock(可自行定义...
  • 多进程文件

    千次阅读 2014-12-17 10:21:09
    对当前读写文件进行加锁处理,简单说下两种加锁方式: flock():文件级别的锁,针对整个文件进行加锁。 flock用于对文件施加建议性锁。 fcntl()函数:段级别的锁,能够针对文件的某个部分进行加锁。 而fcntl...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

linux读写文件加锁

linux 订阅