精华内容
下载资源
问答
  • 多个线程多个锁:多个线程,每个线程都可以拿到自己指定的,分别获得之后,执行synchronized方法体内容。 关键字synchronized取得的都是对象,而不是把一段代码(方法)当做,哪个线程先执行synchronized...

    多个线程多个锁:多个线程,每个线程都可以拿到自己指定的锁,分别获得锁之后,执行synchronized方法体内容。

    关键字synchronized取得的锁都是对象锁,而不是把一段代码(方法)当做锁,哪个线程先执行synchronized关键字的方法,那个线程就持有该方法所属对象的锁(Lock),两个对象,线程获得的就是两个不同的锁,他们互不影响。

    有一种特殊情况则是相同的锁,即在静态方法上加synchronized关键字,表示锁定class类,类一级别的锁(独占.class类)


    从打印的结果我们可以看出,输出的结果有问题。因为我们在printNum方法上加了synchronized锁,那么应该是线程m1输出tag b,set count over!、taga,count=100之后才会打印b的信息。为什么会造成这样的结果呢???

    原来我们声明了t1和t2两个对象,在m1线程中调取t1对象,拥有的是t1对象的锁,而m2线程中调取t2对象,拥有的是t2对象的锁。关键字synchronized取得的锁都是对象锁,这样他们就互不影响,t1和t2的信息都保存在自己的线程栈中,对其他线程不可见,所有m1和m2并发执行。

    如果在printNum方法上加上static关键字,,表示锁定class类。不管声明多少个MultiThread引用,printNum方法跟随类存放在堆上,线程间会共享资源,输出结果会等m1信息输出结束之后才会开始输出m2信息。


    总结:

    一个对象一把锁

    在静态方法上synchronized代表的是类的锁


    本人在码云上提交了关于阅读spring源码之后编写的一些基础模块的实现,https://git.oschina.net/73hulu/spring.git 望大家不吝给颗星star,谢谢大家

    展开全文
  • c++中多个线程使用同一个函数

    千次阅读 2018-08-14 10:18:33
    在创建线程池(构造函数中)时创建若干个线程,起始时由于任务队列中没有任务,创建的每一个线程都处于阻塞状态。使用pthread_create函数创建线程时把所有的线程与一个函数关联在一起,也就是产生如下的代码: ...

    我是小白,最近在学习实现一个简单的线程池,线程池中维护了一个存放线程的数组以及一个任务队列。在创建线程池(构造函数中)时创建若干个线程,起始时由于任务队列中没有任务,创建的每一个线程都处于阻塞状态。使用pthread_create函数创建线程时把所有的线程与同一个函数关联在一起,也就是产生如下的代码:

    pthread_t p[5]; //线程池中有5个线程

    for(int i = 0; i < 5; ++i)

    {

    pthread_create(&p[i], NULL, func, NULL);

    }

    看到这儿,我心里产生了一个疑问:可不可以将所有的线程都关联同一个回调函数func呢?

    经过网上查阅相关资料,是可以这样做的,并且即使使用同一个函数这些函数之间也是互不影响的。每个进程都会有自己的虚拟地址空间,同一个进程中的每个线程都会在这个虚拟空间中,并被分配相应的资源。如果仅仅只使用函数内部的局部变量,这些线程之间是互不相关的,各执行各自的,不用使用互斥锁。如果不同的线程访问了全局变量那么要使用互斥锁,使得某一时刻只有一个线程操作该全局变量。

    下面通过一个代码说明两个线程关联一个函数:

    1. #include <pthread.h>
    2. #include <iostream>
    3. using namespace std;
    4. void *print(void *arg)
    5. {
    6. for (int i = 0; i < 20; ++i)
    7. {
    8. cout << i << endl;
    9. }
    10. return NULL;
    11. }
    12. int main()
    13. {
    14. pthread_t p1, p2;
    15. pthread_create(&p1, NULL, print, NULL);
    16. pthread_create(&p2, NULL, print, NULL);
    17. pthread_join(p1, NULL);
    18. pthread_join(p2, NULL);
    19. return 0;
    20. }



    从结果可以看出这两个线程都使用了print函数,它们各自执行各自的,不会因为使用了同一个函数而受到影响。

    1.两个线程调用同一个函数

     两个线程中的函数的局部变量由于是保存在不同的线程中,因此不需要进行互斥处理(除非有非栈内存在捣乱,这种情况必须要有互斥锁)

    2.两个不同进程中的两个线程调用同一个处理函数

    同样,两个线程中的函数的局部变量由于是保存在不同的线程中,因此不需要进行互斥处理



    展开全文
  • 多线程线程锁使用

    千次阅读 2018-05-07 13:15:40
    多线程的程序编写中,常常遇到共享资源使用冲突解决的苦恼。终于看到并测试了一种简单方法。线程锁的5要素:CRITICAL_SECTION g_cs; //定义线程锁InitializeCriticalSection(&amp;g_cs); //初始化...

    在多线程的程序编写中,常常遇到共享资源使用冲突解决的苦恼。终于看到并测试了一种简单方法。

    线程锁的5个要素:

    CRITICAL_SECTION g_cs;  //定义线程锁

    InitializeCriticalSection(&g_cs);    //初始化

    DeleteCriticalSection(&g_cs);    //删除

    EnterCriticalSection(&g_cs);    //加锁

    LeaveCriticalSection(&g_cs);    //释放锁


    下面是测试程序locktest.cpp:

    #include <iostream>

    #include <windows.h>

    using namespace std;


    CRITICAL_SECTION g_cs;


    DWORD WINAPI fThread1(LPVOID lpParameter)

    {
    int i,j;
    for(i=0;i<3;i++)
    {
    for(j=0;j<3;j++)
    {
      EnterCriticalSection(&g_cs);
       
      cout<<"fThread1 ----: "<<i<<"  "<<j<<endl;
      LeaveCriticalSection(&g_cs);
      Sleep(1);
    }
    }
     return 0;
    }


    DWORD WINAPI fThread2(LPVOID lpParameter)
    {
    int i,j;
    for(i=0;i<3;i++)
    {
    EnterCriticalSection(&g_cs);
    for(j=0;j<3;j++)
    {
      //EnterCriticalSection(&g_cs);
       
      cout<<"fThread2 ****: "<<i<<"  "<<j<<endl;
      //LeaveCriticalSection(&g_cs);
      Sleep(1);
    }
    LeaveCriticalSection(&g_cs);
    Sleep(1);
    }
     return 0;
    }


    int main()
    {
     HANDLE hThread1;
     HANDLE hThread2;


      cout<<"init: "<<endl;
     InitializeCriticalSection(&g_cs);


     hThread1 = CreateThread(NULL,0,fThread1,NULL,0,NULL);
     hThread2 = CreateThread(NULL,0,fThread2,NULL,0,NULL);
     CloseHandle(hThread1);
     CloseHandle(hThread2);


     Sleep(4000);
     DeleteCriticalSection(&g_cs);
     return 0;

    }

    运行结果显示:

    这个运行结果说明锁定区间内,其他程序不能打扰,抢占资源。

    线程1加锁在内循环,每次锁定一行显示,而线程2加锁在for(j=...) 外围,所以每次锁定3行显示。线程2结束后,资源就全是线程1的了。

    为了对比,修改线程2 加锁的位置,也到最内循环,结果如下:


    可以看到,线程显示是交替的。线程1显示1行,线程2显示1行,直到结束。


    展开全文
  • java 多个线程同时写一个文件

    千次阅读 2019-10-11 17:00:17
    话不说,先直接上代码: 主方法: import java.util.concurrent.CountDownLatch; /** * @ProjectName: emp_customer * @Package: PACKAGE_NAME * @ClassName: Test * @Author: Administrator * @...

    话不多说,先直接上代码:

    主方法:

    import java.util.concurrent.CountDownLatch;
    
    /**
     * @ProjectName: emp_customer
     * @Package: PACKAGE_NAME
     * @ClassName: Test
     * @Author: Administrator
     * @Description: ${description}
     * @Date: 2019/10/11 14:10
     * @Version: 1.0
     */
    public class Test {
         public static void main(String args[]){
    
             //线程数
             int threadSize=4;
             //源文件地址
             String sourcePath = "E:\\1\\4.txt";
             //目标文件地址
             String destnationPath = "E:\\2\\4.txt";
             //
             CountDownLatch latch = new CountDownLatch(threadSize);
             MultiDownloadFileThread m = new MultiDownloadFileThread(threadSize, sourcePath, destnationPath, latch);
             long startTime = System.currentTimeMillis();
             try {
                 m.excute();
                 latch.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             long endTime = System.currentTimeMillis();
             System.out.println("全部下载结束,共耗时" + (endTime - startTime) / 1000 + "s");
         }
    
    }
    

     

    线程类:

    import java.io.*;
    import java.nio.channels.FileChannel;
    import java.nio.channels.FileLock;
    import java.util.concurrent.CountDownLatch;
    
    /**
     * @ProjectName: emp_customer
     * @Package: PACKAGE_NAME
     * @ClassName: MultiDownloadFileThread
     * @Author: Administrator
     * @Description: ${description}
     * @Date: 2019/10/11 15:03
     * @Version: 1.0
     */
    public class MultiDownloadFileThread {
    
        private int threadCount;
        private String sourcePath;
        private String targetPath;
        private CountDownLatch latch;
    
        public MultiDownloadFileThread(int threadCount, String sourcePath, String targetPath, CountDownLatch latch) {
            this.threadCount = threadCount;
            this.sourcePath = sourcePath;
            this.targetPath = targetPath;
            this.latch = latch;
        }
    
        public void excute() {
            File file = new File(sourcePath);
            int fileLength = (int) file.length();
            //分割文件
            int blockSize = fileLength / threadCount;
            for (int i = 1; i <= threadCount; i++) {
                //第一个线程下载的开始位置
                int startIndex = (i - 1) * blockSize;
                int endIndex = startIndex + blockSize - 1;
                if (i == threadCount) {
                    //最后一个线程下载的长度稍微长一点
                    endIndex = fileLength;
                }
                System.out.println("线程" + i + "下载:" + startIndex + "字节~" + endIndex + "字节");
                new DownLoadThread(i, startIndex, endIndex).start();
            }
        }
    
    
        public class DownLoadThread extends Thread {
            private int i;
            private int startIndex;
            private int endIndex;
    
            public DownLoadThread(int i, int startIndex, int endIndex) {
                this.i = i;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
            }
    
            @Override
            public void run() {
                File file = new File(sourcePath);
                FileInputStream in = null;
                RandomAccessFile raFile = null;
                FileChannel fcin = null;
                FileLock flin = null;
                try {
                    in = new FileInputStream(file);
                    in.skip(startIndex);
                    //给要写的文件加锁
                    raFile = new RandomAccessFile(targetPath, "rwd");
                    fcin =raFile.getChannel();
                    while(true){
                        try {
                            flin = fcin.tryLock();
                            break;
                        } catch (Exception e) {
                            System.out.println("有其他线程正在操作该文件,当前线程休眠1000毫秒,当前进入的线程为:"+i);
                            sleep(1000);
                        }
                    }
                    //随机写文件的时候从哪个位置开始写
                    raFile.seek(startIndex);
                    int len = 0;
                    byte[] arr = new byte[1024];
                    //获取文件片段长度
                    int segLength = endIndex - startIndex + 1;
                    while ((len = in.read(arr)) != -1) {
                        if (segLength > len) {
                            segLength = segLength - len;
                            raFile.write(arr, 0, len);
                        } else {
                            raFile.write(arr, 0, segLength);
                            break;
                        }
                    }
                    System.out.println("线程" + i + "下载完毕");
                    //计数值减一
                    latch.countDown();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if (in != null) {
                            in.close();
                        }
                        if (raFile != null) {
                            raFile.close();
                        }
    
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    运行结果:

     

    涉及到的相关知识点:

    1.CountDownLatch 

    2.RandomAccessFile

    3.FileLock

    下面我们具体讲解下

    一、FileLock :文件锁

    FileLock是java 1.4 版本后出现的一个类,它可以通过对一个可写文件(w)加锁,保证同时只有一个进程可以拿到文件的锁,这个进程从而可以对文件做访问;而其它拿不到锁的进程要么选择被挂起等待,要么选择去做一些其它的事情, 这样的机制保证了众进程可以顺序访问该文件。

    1. 概念

    • 共享锁: 共享读操作,但只能一个写(读可以同时,但写不能)。共享锁防止其他正在运行的程序获得重复的独占锁,但是允许他们获得重复的共享锁。
    • 独占锁: 只有一个读或一个写(读和写都不能同时)。独占锁防止其他程序获得任何类型的锁。

    2. lock()和tryLock()的区别:

    lock()阻塞的方法,锁定范围可以随着文件的增大而增加。无参lock()默认为独占锁;有参lock(0L, Long.MAX_VALUE, true)为共享锁。
    tryLock()非阻塞,当未获得锁时,返回null.
    3. FileLock的生命周期:在调用FileLock.release(),或者Channel.close(),或者JVM关闭

    4. FileLock是线程安全的
     

    二、RandomAccessFile

    java除了File类之外,还提供了专门处理文件的类,即RandomAccessFile(随机访问文件)类。该类是Java语言中功能最为丰富的文件访问类,它提供了众多的文件访问方法。RandomAccessFile类支持“随机访问”方式,这里“随机”是指可以跳转到文件的任意位置处读写数据。在访问一个文件的时候,不必把文件从头读到尾,而是希望像访问一个数据库一样“随心所欲”地访问一个文件的某个部分,这时使用RandomAccessFile类就是最佳选择。

    RandomAccessFile对象类有个位置指示器,指向当前读写处的位置,当前读写n个字节后,文件指示器将指向这n个字节后面的下一个字节处。刚打开文件时,文件指示器指向文件的开头处,可以移动文件指示器到新的位置,随后的读写操作将从新的位置开始。RandomAccessFile类在数据等长记录格式文件的随机(相对顺序而言)读取时有很大的优势,但该类仅限于操作文件,不能访问其他的I/O设备,如网络、内存映像等。RandomAccessFile类的构造方法如下所示:

    RandomAccessFile(File file ,  String mode)
    //创建随机存储文件流,文件属性由参数File对象指定

    RandomAccessFile(String name ,  String mode)
    //创建随机存储文件流,文件名由参数name指定

    这两个构造方法均涉及到一个String类型的参数mode,它决定随机存储文件流的操作模式,其中mode值及对应的含义如下:

    “r”:以只读的方式打开,调用该对象的任何write(写)方法都会导致IOException异常
    “rw”:以读、写方式打开,支持文件的读取或写入。若文件不存在,则创建之。
    “rws”:以读、写方式打开,与“rw”不同的是,还要对文件内容的每次更新都同步更新到潜在的存储设备中去。这里的“s”表示synchronous(同步)的意思
    “rwd”:以读、写方式打开,与“rw”不同的是,还要对文件内容的每次更新都同步更新到潜在的存储设备中去。使用“rwd”模式仅要求将文件的内容更新到存储设备中,而使用“rws”模式除了更新文件的内容,还要更新文件的元数据(metadata),因此至少要求1次低级别的I/O操作

     

    三、CountDownLatch

    1.概念

    • countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。
    • 是通过一个计数器来实现的,计数器的初始值是线程的数量。每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。

    2.源码

    • countDownLatch类中只提供了一个构造器:
    //参数count为计数值
    public CountDownLatch(int count) {  };  
    
    • 类中有三个方法是最重要的:
    //调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
    public void await() throws InterruptedException { };   
    //和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
    public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
    //将count值减1
    public void countDown() { };  

    假如在我们的代码里面,我们把main方法里面的

    latch.await();

    注释掉

    如下所示:

    我们可以看到跟之前的输出结果相比,我们的主方法里面输出的:全部下载结束的输出信息,已经打印到我们执行文件下载的线程输出信息的前面了,说明主线程先执行完。这从而说明,await() 方法具有阻塞作用

     我们在把latch.await();放开,把文件下载线程里的latch.countDown();注释掉,

    如下:

    我们可以看到,主程序里的的输出;全部下载结束的输出信息,一直未输出,程序也一直未结束,由此可得,countDown() 方法具有唤醒阻塞线程的作用。

    那么如何让 CountdownLatch 尽早结束

    假如我们的程序执行到countDown()之前就抛出异常,这就可能导致一整情况,CountdownLatch 计数永远不会达到零并且 await() 永远不会终止。

    为了解决这个问题,我们在调用 await() 时添加一个超时参数。

     

    CountDownLatch总结:

        1、CountDownLatch end = new CountDownLatch(N); //构造对象时候 需要传入参数N

      2、end.await()  能够阻塞线程 直到调用N次end.countDown() 方法才释放线程,最好设置超时参数

      3、end.countDown() 可以在多个线程中调用  计算调用次数是所有线程调用次数的总和

     

    对于,本demo而言,加不加文件锁的意义不大,因为在进入线程写的时候,就已经告诉单个线程需要写的内容是哪一块到哪一块,不加锁,也会正常写入,切经本人测试无误,但若是对同一个文件,即要写,又要读话,就必须加锁,不然程序执行可能不完整,具体情况可以查看下面的这个博客:https://blog.csdn.net/gxy3509394/article/details/7435993

    展开全文
  • Java多线程--多个对象多个锁

    千次阅读 热门讨论 2018-06-04 17:22:05
    上一篇博客中介绍了多个线程同时访问一个对象,产生一个对象,属于同步访问,现在介绍下如果是访问多个对象,会怎么执行那? Demo: HasSelfPrivateNum类: public class HasSelfPrivateNum { private int num=...
  • MFC多线程互斥使用

    千次阅读 2019-10-04 23:14:12
    第二部分实现两个线程互斥使用。 演示系统为Win10,平台为VS2017(MFC),主要使用类为CWinThread。 第二部分: 1.在原有基础上(见上一篇文章MFC线程的开启、暂停、继续和注销)添加一个EDIT控件和一个线程...
  • 多个线程调用一个线程函数

    千次阅读 2012-03-08 20:15:53
    多个线程调用一个线程函数 悬赏分:50 - 解决时间:2007-12-11 13:59 如题,能这样吗?因为有很多个操作,但是这些操作都是一样的,所以想用相同的线程函数,但是感觉运行时线程还是一个一个运行,并没有...
  • Qt多线程基础(一)线程同步之互斥同步

    万次阅读 多人点赞 2016-11-04 13:45:08
    互斥同步方法:void run()函数中使用QMutex来实现同步,当多个线程访问共享变量时,应使用lock/trylock和unlock将对共享变量的操作代码包裹,以保证同步访问共享变量。(C++中引起线程安全的共享资源只有
  • Qt多线程使用互斥

    万次阅读 2018-09-04 22:08:06
    这样每次只有一个线程可以访问它(这类似于Java synchronized关键字)。 通常最好将互斥对象与QMutexLocker一起使用,因为这样可以很容易地确保一致地执行锁定和解锁。 2、官方示例: QMutex mutex; ...
  • C++11 多线程同步 互斥 条件变量

    千次阅读 2017-03-04 21:21:26
    在多线程程序中,线程同步(多个线程访问一个资源保证顺序)是一个非常重要的问题,Linux下常见的线程同步的方法有下面几种: 互斥 条件变量 信号量 这篇博客只介绍互斥量和条件变量的使用。互斥和条件变量通常...
  • 一、何为线程同步 在前一篇文章《C++多线程并发编程...线程间通信:一个任务被分割为多个线程并发处理,多个线程可能都要处理某一共享内存的数据,多个线程对同一共享内存数据的访问需要准确有序。 如果像前一篇文...
  •  首先我这边是实际开发中使用到了,开发的环境情况为:有一数据中心(暂且当做一Map集合),有两线程A、B,其中A线程每5秒钟从其他地方获取到新来的数据然后和数据中心里面的数据进行一融合,然后B线程...
  • Window多线程同步之(互斥)

    千次阅读 2017-12-22 14:41:45
    简述 互斥是用在多线程间对操作同一资源进行互斥的。一个线程占用了一个资源,那么别的线程就操作此资源,直到这个线程该释放互斥...比如多个线程对一个全局变量进行累加并打印。 源码 //共享资源 static int num
  • 1.在java多线程编程中对象、类、... 类:是用于一个类静态方法或者class对象的,一个类的实例对象可以有多个,但是只有一个class对象。  同步机制synchronized:synchronized关键字用于修饰方法或者单独的sy
  • C#多线程使用

    千次阅读 2015-07-19 12:08:08
    最近的项目中涉及到实时数据的处理,经常会使用多线程访问共享资源。...当时项目的模式是这样的:有一个类中有个共享的资源(List),这个类会开辟两个线程分别对它进行读和写操作,而且这个类会有多个实例,
  • Java多线程锁释放

    千次阅读 2016-06-20 23:19:15
    Java多线程锁释放
  • 但在最近查线上日志的时候偶然发现,有一个业务场景下,分布式偶尔会失效,导致有多个线程同时执行了相同的代码。 我们经过初步排查,定位到是因为在这段代码中间调用了第三方的接口导致。 因为...
  • 使用多线程及互斥样例:#include &lt;iostream&gt; #include &lt;windows.h&gt; using namespace std; HANDLE hMutex = NULL;//互斥量 //线程函数 DWORD WINAPI Fun(LPVOID lpParamter) { for ...
  • 假设有三个线程:1、2、3,各自打印A,B,C。 是否可以只用互斥就实现“ACBCACBC……”的打印输出? (不使用其他的线程同步方法)
  • C#多线程锁

    千次阅读 2017-04-18 19:33:43
    c#多线程操作队列
  • 问题背景:在工作中遇到过一个问题,就是在两个线程同时调用一个函数的时候,到底是应该在这个函数的内部什么处理上加上互斥。原因又是什么? 为了调查这个问题,我决定从以下三方面调查 1.线程中函数的调用 2....
  • 看到这个问题第一反应是不懂,然后查询了网上的一些说法,感觉略有不一。...然后,多个线程访问这个类的两个方法也有不同的形式,例如访问这个类的两个方法是通过一个类的实例对象来访问还是通过不同...
  • 题目:多线程之间按顺序调用,实现A->...思路:使用Lock多个Condition实现精准唤醒。 package com.bestqiang.thread.Queue; /** * @author BestQiang */ import java.util.concurrent.loc...
  • Java多线程安全问题和

    千次阅读 2020-02-28 17:32:26
    多个线程同时操作一个数据是,可能会出现数据不一样的情况,这就是线程安全问题。 线程安全机制用于保证多个线程访问数据时的一致性. 线程安全问题体现在三个方面: 1、原子性 2、可见性 3、有序性 原子操作是不...
  • 多线程锁使用的原则

    千次阅读 2017-01-12 15:22:56
    规则10.1 多线程、进程并行访问共享资源时,一定要加锁保护  说明:共享资源包括全局变量,静态变量,共享内存,文件等。 建议封装像智能指针一样的对象对锁进行管理,比如我们就封装了一auto_lock,在构造时...
  • 秒杀多线程第四篇 一经典的多线程同步问题

    万次阅读 多人点赞 2012-04-10 09:57:02
    上一篇《秒杀多线程第三篇原子操作 Interlocked系列函数》中介绍了原子操作在进程中的作用,现在来复杂点的。这问题涉及到线程的同步和互斥,是一道非常有代表性的多线程同步问题,如果能将这问题搞清楚,...
  • Java使用循环创建多个线程

    千次阅读 2019-05-19 23:31:13
    使用start()方法启动线程,则立即开始创建下一个线程。 测试代码及结果如下: 情景:循环创建一类线程,这类线程的run()方法不能立即结束,如包含循环等。 问题:创建线程后,启动线程时,使用run(...
  • 具体实现思路就举个列子说明吧: 假设有10000个字节需要写入某个文件,为了加快写入速度,可以开启2个线程,第一个线程将前5000个字节写入文件0~4999的位置,另外一个线程将后5000个字节写入文件5000~9999的位置,等...
  • 多个线程如何操作一个epoll fd

    万次阅读 2014-08-31 13:20:17
    自己以前做一个接口服务器时候,这种场景下我的设计是多个线程操作一个epoll fd。彼时,我的理由是epoll的系列函数是线程安全的。  当然有人不理解为什么会有多个线程操作一个epoll fd的情形,这里稍微铺陈...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,097,379
精华内容 838,951
关键字:

多个线程使用同多个锁