程序员经验分享-hwhale

线程间的通讯

2023-11-01

一.为什么需要线程通讯

线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。

线程间的通讯定义：多个线程在操作同一份数据时，互相告知自己的状态，避免对同一共享变量的争夺。 

二.线程间的通讯方式

线程通讯的方式主要可以分为三种方式，共享内存、消息传递和管道流。

 1.共享内存

        （1）同步–synchronized

线程同步是线程之间按照⼀定的顺序执⾏，可以使⽤锁来实现达到线程同步，也就是在需要同步的代码块里加上关键字synchronized 。因为⼀个锁同⼀时间只能被⼀个线程持有。

synchronized可以修饰方法或者以同步块，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

 基于synchronized实现线程A和线程B通信
线程A执行完，再让线程B执行，使用对象锁实现


    
    
    

  1. 
      
      
      
      
    
       
       
    
        
        public 
        
        class 
        
        SynchronizedTest {
       
       
    
      
      
    

    2. 

  2. 
      
      
      
      
    
       
       
        
        
        static  
        
        Object 
        
        obj 
        
        = 
        
        new 
        
        Object();
       
       
    
      
      
    

    3. 

  3. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadA 
        
        implements 
        
        Runnable{
       
       
    
      
      
    

    4. 

  4. 
      
      
      
      

    5. 

  5. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    6. 

  6. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    7. 

  7. 
      
      
      
      
    
       
       
                
        
        synchronized (obj){
       
       
    
      
      
    

    8. 

  8. 
      
      
      
      
    
       
       
                    
        
        for (
        
        int 
        
        i 
        
        = 
        
        0; i < 
        
        5; i++) {
       
       
    
      
      
    

    9. 

  9. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "ThreadA" + i);
       
       
    
      
      
    

    10. 

  10. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    11. 

  11. 
      
      
      
      

    12. 

  12. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    13. 

  13. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    14. 

  14. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    15. 

  15. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadB 
        
        implements 
        
        Runnable{
       
       
    
      
      
    

    16. 

  16. 
      
      
      
      

    17. 

  17. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    18. 

  18. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    19. 

  19. 
      
      
      
      
    
       
       
                
        
        synchronized (obj){
       
       
    
      
      
    

    20. 

  20. 
      
      
      
      
    
       
       
                    
        
        for (
        
        int 
        
        i 
        
        = 
        
        0; i < 
        
        5; i++) {
       
       
    
      
      
    

    21. 

  21. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "ThreadB" + i);
       
       
    
      
      
    

    22. 

  22. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    23. 

  23. 
      
      
      
      

    24. 

  24. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    25. 

  25. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    26. 

  26. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    27. 

  27. 
      
      
      
      

    28. 

  28. 
      
      
      
      
    
       
       
        
        
        public 
        
        static 
        
        void 
        
        main
        
        (String[] args) {
       
       
    
      
      
    

    29. 

  29. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threada 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadA());
       
       
    
      
      
    

    30. 

  30. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threadb 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadB());
       
       
    
      
      
    

    31. 

  31. 
      
      
      
      
    
       
       
    
        
                threada.start();
       
       
    
      
      
    

    32. 

  32. 
      
      
      
      
    
       
       
    
        
                threadb.start();
       
       
    
      
      
    

    33. 

  33. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    34. 

  34. 
      
      
      
      
    
       
       
    
        
        }
       
       
    
      
      
    

    35.

运行结果

 

 线程A和线程B需要访问同一个对象lock，谁获得锁，谁就先执行。线程B要等线程A执行完再执行，所以是同步的，这就实现了线程间的通信

      （2）信号量 --volatile


在java中，所有堆内存中的所有的数据（实例域、静态域和数组元素）存放在主内存中可以在线程之间共享，一些局部变量、方法中定义的参数存放在本地内存中不会在线程间共享。线程之间的共享变量存储在主内存中，本地内存存储了共享变量的副本。如果线程A要和线程B通信，则需要经过以下步骤

  1. 线程A把本地内存A更新过的共享变量刷新到主内存中
  2. 线程B到内存中去读取线程A之前已更新过的共享变量。

为保证线程间的通信必须经过主内存。需要关键字volatile。

volatile保证内存可见性，即多个线程访问内存中的同一个被volatile关键字修饰的变量时，当某一个线程修改完该变量后，需要先将这个最新修改的值写回到主内存，从而保证下一个读取该变量的线程取得的就是主内存中该数据的最新值，这样就保证线程之间的透明性，便于线程通信。

 

 基于volatile关键字实现线程A和线程B的通信
线程A输出0，然后线程B输出1，再然后线程A输出2…


    
    
    

  1. 
      
      
      
      
    
       
       
    
        
        public 
        
        class 
        
        VolatileTest {
       
       
    
      
      
    

    2. 

  2. 
      
      
      
      
    
       
       
        
        
        static 
        
        volatile 
        
        int 
        
        s 
        
        = 
        
        0;
       
       
    
      
      
    

    3. 

  3. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadA 
        
        implements 
        
        Runnable {
       
       
    
      
      
    

    4. 

  4. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    5. 

  5. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    6. 

  6. 
      
      
      
      
    
       
       
                
        
        while (s < 
        
        10) {
       
       
    
      
      
    

    7. 

  7. 
      
      
      
      
    
       
       
                    
        
        if (s % 
        
        2 == 
        
        0) {
       
       
    
      
      
    

    8. 

  8. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "ThreadA: " + s);
       
       
    
      
      
    

    9. 

  9. 
      
      
      
      
    
       
       
                        
        
        synchronized (
        
        this) {
       
       
    
      
      
    

    10. 

  10. 
      
      
      
      
    
       
       
    
        
                                s++;
       
       
    
      
      
    

    11. 

  11. 
      
      
      
      
    
       
       
    
        
                            }
       
       
    
      
      
    

    12. 

  12. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    13. 

  13. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    14. 

  14. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    15. 

  15. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    16. 

  16. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadB 
        
        implements 
        
        Runnable {
       
       
    
      
      
    

    17. 

  17. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    18. 

  18. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    19. 

  19. 
      
      
      
      
    
       
       
                
        
        while (s < 
        
        10) {
       
       
    
      
      
    

    20. 

  20. 
      
      
      
      
    
       
       
                    
        
        if (s % 
        
        2 == 
        
        1) {
       
       
    
      
      
    

    21. 

  21. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "ThreadB: " + s);
       
       
    
      
      
    

    22. 

  22. 
      
      
      
      
    
       
       
                        
        
        synchronized (
        
        this) {
       
       
    
      
      
    

    23. 

  23. 
      
      
      
      
    
       
       
    
        
                                s++;
       
       
    
      
      
    

    24. 

  24. 
      
      
      
      
    
       
       
    
        
                            }
       
       
    
      
      
    

    25. 

  25. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    26. 

  26. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    27. 

  27. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    28. 

  28. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    29. 

  29. 
      
      
      
      
    
       
       
        
        
        public 
        
        static 
        
        void 
        
        main
        
        (String[] args) {
       
       
    
      
      
    

    30. 

  30. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threada 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadA());
       
       
    
      
      
    

    31. 

  31. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threadb 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadB());
       
       
    
      
      
    

    32. 

  32. 
      
      
      
      
    
       
       
    
        
                threada.start();
       
       
    
      
      
    

    33. 

  33. 
      
      
      
      
    
       
       
    
        
                threadb.start();
       
       
    
      
      
    

    34. 

  34. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    35. 

  35. 
      
      
      
      
    
       
       
    
        
        }
       
       
    
      
      
    

    36.

运行结果

volatile 变量需要进⾏原⼦操作。 signal++ 并不是⼀个原⼦操作，所以我们需要使⽤ synchronized 给它“上锁” 

 2.消息传递

等待/通知机制（wait/notify）：一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。等待/通知机制使⽤的是使⽤同⼀个对象锁，如果你两个线程使⽤的是不同的对象锁，那它们之间是不能⽤等待/通知机制通信的。

wait()当前线程释放锁并进入等待(阻塞)状态，notify()唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后继续竞争锁notifyAll()唤醒所有正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后继续竞争锁 

notify()和notifyAll()的区别：
notify()⽅法会随机叫醒⼀个正在等待的线程，⽽notifyAll()会叫醒所有正在等待的线程。

 

基于Object 类的 wait() ⽅法和 notify() ⽅法实现
 


    
    
    

  1. 
      
      
      
      
    
       
       
    
        
        public 
        
        class 
        
        WaitandNotify {
       
       
    
      
      
    

    2. 

  2. 
      
      
      
      
    
       
       
        
        
        static 
        
        boolean 
        
        flag 
        
        = 
        
        true;
       
       
    
      
      
    

    3. 

  3. 
      
      
      
      
    
       
       
        
        
        static  
        
        Object 
        
        obj 
        
        = 
        
        new 
        
        Object();
       
       
    
      
      
    

    4. 

  4. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadA 
        
        implements 
        
        Runnable {
       
       
    
      
      
    

    5. 

  5. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    6. 

  6. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    7. 

  7. 
      
      
      
      
    
       
       
                
        
        synchronized (obj) {
       
       
    
      
      
    

    8. 

  8. 
      
      
      
      
    
       
       
                    
        
        while (flag){
       
       
    
      
      
    

    9. 

  9. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "flag为true，不满足条件，继续等待");
       
       
    
      
      
    

    10. 

  10. 
      
      
      
      
    
       
       
                        
        
        try {
       
       
    
      
      
    

    11. 

  11. 
      
      
      
      
    
       
       
    
        
                                obj.wait();
       
       
    
      
      
    

    12. 

  12. 
      
      
      
      
    
       
       
    
        
                            } 
        
        catch (InterruptedException e) {
       
       
    
      
      
    

    13. 

  13. 
      
      
      
      
    
       
       
    
        
                                e.printStackTrace();
       
       
    
      
      
    

    14. 

  14. 
      
      
      
      
    
       
       
    
        
                            }
       
       
    
      
      
    

    15. 

  15. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    16. 

  16. 
      
      
      
      
    
       
       
    
        
                        System.out.println(
        
        "flag为false,我要从wait状态返回继续执行了");
       
       
    
      
      
    

    17. 

  17. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    18. 

  18. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    19. 

  19. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    20. 

  20. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ThreadB 
        
        implements 
        
        Runnable {
       
       
    
      
      
    

    21. 

  21. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    22. 

  22. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    23. 

  23. 
      
      
      
      
    
       
       
                
        
        synchronized (obj) {
       
       
    
      
      
    

    24. 

  24. 
      
      
      
      
    
       
       
                    
        
        while (flag){
       
       
    
      
      
    

    25. 

  25. 
      
      
      
      
    
       
       
    
        
                            obj.notifyAll();
       
       
    
      
      
    

    26. 

  26. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "设置flag为false,我发出通知了，但是我不会立马释放锁");
       
       
    
      
      
    

    27. 

  27. 
      
      
      
      
    
       
       
    
        
                            flag = 
        
        false;
       
       
    
      
      
    

    28. 

  28. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    29. 

  29. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    30. 

  30. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    31. 

  31. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    32. 

  32. 
      
      
      
      
    
       
       
        
        
        public 
        
        static 
        
        void 
        
        main
        
        (String[] args) {
       
       
    
      
      
    

    33. 

  33. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threada 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadA());
       
       
    
      
      
    

    34. 

  34. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threadb 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ThreadB());
       
       
    
      
      
    

    35. 

  35. 
      
      
      
      
    
       
       
    
        
                threada.start();
       
       
    
      
      
    

    36. 

  36. 
      
      
      
      
    
       
       
    
        
                threadb.start();
       
       
    
      
      
    

    37. 

  37. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    38. 

  38. 
      
      
      
      
    
       
       
    
        
        }
       
       
    
      
      
    

    39.

运行结果

 

3.管道流

管道输入/输出流用于线程之间的数据传输，传输的媒介为管道（内存）
管道输入/输出流的体现：
基于字节流：PipedOutputStrean、PipedInputStrean
基于字符：PipedReader，PipedWriter


    
    
    

  1. 
      
      
      
      
    
       
       
    
        
        public 
        
        class 
        
        WaitandNotify {
       
       
    
      
      
    

    2. 

  2. 
      
      
      
      
    
       
       
        
        
        static 
        
        boolean 
        
        flag 
        
        = 
        
        true;
       
       
    
      
      
    

    3. 

  3. 
      
      
      
      
    
       
       
        
        
        static  
        
        Object 
        
        obj 
        
        = 
        
        new 
        
        Object();
       
       
    
      
      
    

    4. 

  4. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        ReaderThread 
        
        implements 
        
        Runnable{
       
       
    
      
      
    

    5. 

  5. 
      
      
      
      
    
       
       
            
        
        private PipedReader in;
       
       
    
      
      
    

    6. 

  6. 
      
      
      
      
    
       
       
            
        
        public 
        
        ReaderThread
        
        (PipedReader in){
       
       
    
      
      
    

    7. 

  7. 
      
      
      
      
    
       
       
                
        
        this.in=in;
       
       
    
      
      
    

    8. 

  8. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    9. 

  9. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    10. 

  10. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    11. 

  11. 
      
      
      
      
    
       
       
    
        
                    System.out.println(
        
        "this is a reader");
       
       
    
      
      
    

    12. 

  12. 
      
      
      
      
    
       
       
                
        
        int receice=
        
        0;
       
       
    
      
      
    

    13. 

  13. 
      
      
      
      
    
       
       
                
        
        try {
       
       
    
      
      
    

    14. 

  14. 
      
      
      
      
    
       
       
                    
        
        while ((receice=in.read())!=-
        
        1){
       
       
    
      
      
    

    15. 

  15. 
      
      
      
      
    
       
       
    
        
                            System.out.println(
        
        "read "+(
        
        char) receice);
       
       
    
      
      
    

    16. 

  16. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    17. 

  17. 
      
      
      
      
    
       
       
    
        
                    }
        
        catch (IOException ex){
       
       
    
      
      
    

    18. 

  18. 
      
      
      
      
    
       
       
    
        
                        ex.printStackTrace();
       
       
    
      
      
    

    19. 

  19. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    20. 

  20. 
      
      
      
      

    21. 

  21. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    22. 

  22. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    23. 

  23. 
      
      
      
      

    24. 

  24. 
      
      
      
      
    
       
       
        
        
        static 
        
        class 
        
        WriterThread 
        
        implements 
        
        Runnable{
       
       
    
      
      
    

    25. 

  25. 
      
      
      
      
    
       
       
            
        
        private PipedWriter out;
       
       
    
      
      
    

    26. 

  26. 
      
      
      
      
    
       
       
            
        
        public 
        
        WriterThread
        
        (PipedWriter out){
       
       
    
      
      
    

    27. 

  27. 
      
      
      
      
    
       
       
                
        
        this.out=out;
       
       
    
      
      
    

    28. 

  28. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    29. 

  29. 
      
      
      
      
    
       
       
            
        
        @Override
       
       
    
      
      
    

    30. 

  30. 
      
      
      
      
    
       
       
            
        
        public 
        
        void 
        
        run
        
        () {
       
       
    
      
      
    

    31. 

  31. 
      
      
      
      
    
       
       
    
        
                    System.out.println(
        
        "this is a writer");
       
       
    
      
      
    

    32. 

  32. 
      
      
      
      
    
       
       
                
        
        try {
       
       
    
      
      
    

    33. 

  33. 
      
      
      
      
    
       
       
    
        
                        out.write(
        
        "write A");
       
       
    
      
      
    

    34. 

  34. 
      
      
      
      
    
       
       
    
        
                    }
        
        catch (IOException ex){
       
       
    
      
      
    

    35. 

  35. 
      
      
      
      
    
       
       
    
        
                        ex.printStackTrace();
       
       
    
      
      
    

    36. 

  36. 
      
      
      
      
    
       
       
    
        
                    }
        
        finally {
       
       
    
      
      
    

    37. 

  37. 
      
      
      
      
    
       
       
                    
        
        try {
       
       
    
      
      
    

    38. 

  38. 
      
      
      
      
    
       
       
    
        
                            out.close();
       
       
    
      
      
    

    39. 

  39. 
      
      
      
      
    
       
       
    
        
                        } 
        
        catch (IOException e) {
       
       
    
      
      
    

    40. 

  40. 
      
      
      
      
    
       
       
    
        
                            e.printStackTrace();
       
       
    
      
      
    

    41. 

  41. 
      
      
      
      
    
       
       
    
        
                        }
       
       
    
      
      
    

    42. 

  42. 
      
      
      
      
    
       
       
    
        
                    }
       
       
    
      
      
    

    43. 

  43. 
      
      
      
      
    
       
       
    
        
                }
       
       
    
      
      
    

    44. 

  44. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    45. 

  45. 
      
      
      
      
    
       
       
        
        
        public 
        
        static 
        
        void 
        
        main
        
        (String[] args) 
        
        throws IOException {
       
       
    
      
      
    

    46. 

  46. 
      
      
      
      
    
       
       
            
        
        PipedWriter 
        
        writer 
        
        = 
        
        new 
        
        PipedWriter();
       
       
    
      
      
    

    47. 

  47. 
      
      
      
      
    
       
       
            
        
        PipedReader 
        
        reader 
        
        = 
        
        new 
        
        PipedReader();
       
       
    
      
      
    

    48. 

  48. 
      
      
      
      
    
       
       
    
        
                writer.connect(reader);
       
       
    
      
      
    

    49. 

  49. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threada 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        ReaderThread(reader));
       
       
    
      
      
    

    50. 

  50. 
      
      
      
      
    
       
       
            
        
        Thread 
        
        threadb 
        
        = 
        
        new 
        
        Thread(
        
        new 
        
        WriterThread(writer));
       
       
    
      
      
    

    51. 

  51. 
      
      
      
      
    
       
       
    
        
                threada.start();
       
       
    
      
      
    

    52. 

  52. 
      
      
      
      
    
       
       
    
        
                threadb.start();
       
       
    
      
      
    

    53. 

  53. 
      
      
      
      
    
       
       
    
        
            }
       
       
    
      
      
    

    54. 

  54. 
      
      
      
      
    
       
       
    
        
        }
       
       
    
      
      
    

    55.

 运行结果

 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

c

Windows

线程间的通讯 的相关文章

  • EntityHydrate 任务失败

    我最近安装了 Visual Studio 11 Beta 和 Visual Studio 2010 之后 我无法在 Visual Studio 2010 中构建依赖于 PostSharp 的项目 因此我卸载了 Visual Studio 1

  • C# 中的 Stack<> 实现

    我最近一直在实现递归目录搜索实现 并且使用堆栈来跟踪路径元素 当我使用 string Join 连接路径元素时 我发现它们被颠倒了 当我调试该方法时 我查看了堆栈 发现堆栈内部数组中的元素本身是相反的 即最近 Push 的元素位于内部数组的

  • strlen() 编译时优化

    前几天我发现你可以找到编译时strlen使用这样的东西 template

  • 在 C++ 代码中转换字符串

    我正在学习 C 并开发一个项目来练习 但现在我想在代码中转换一个变量 字符串 就像这样 用户有一个包含 C 代码的文件 但我希望我的程序读取该文件并插入将其写入代码中 如下所示 include

  • Boost ASIO 串行写入十六进制值

    我正在使用 ubuntu 通过串行端口与设备进行通信 所有消息都必须是十六进制值 我已经在 Windows 环境中使用白蚁测试了通信设置 并得到了我期望的响应 但在使用 Boost asio 时我无法得到任何响应 以下是我设置串口的方法 b

  • 防止控制台应用程序中的内存工作集最小化？

    我想防止控制台应用程序中的内存工作集最小化 在Windows应用程序中 我可以这样做覆盖 SC MINIMIZE 消息 http support microsoft com kb 293215 en us fr 1 但是 如何在控制台应用程

  • Android NDK 代码中的 SIGILL

    我在市场上有一个 NDK 应用程序 并获得了有关以下内容的本机崩溃报告 SIGILL信号 我使用 Google Breakpad 生成本机崩溃报告 以下是详细信息 我的应用程序是为armeabi v7a with霓虹灯支持 它在 NVIDI

  • Makefile 和 .Mak 文件 + CodeBlocks 和 VStudio

    我对整个 makefile 概念有点陌生 所以我对此有一些疑问 我正在 Linux 中使用 CodeBlocks 创建一个项目 我使用一个名为 cbp2mak 的工具从 CodeBlocks 项目创建一个 make 文件 如果有人知道更好的

  • JavaScript 错误：MVC2 视图中的条件编译已关闭

    我试图在 MVC2 视图页面中单击时调用 JavaScript 函数 a href Select a JavaScript 函数 function SelectBenefit id code alert id alert code 这里 b

  • 调整屏幕和字体设置的 WPF 应用程序（或者，我如何将 DLU 与 WPF 中的单元相关联？）

    在MFC中 对话框的设计使用DLUs http msdn microsoft com en us library bb847924 aspx 在 WPF 中 我们以 1 96 英寸为单位指定 虽然这确实会缩放窗口和视觉元素 但我们如何使 W

  • 如何防止 Blazor NavLink 组件的默认导航

    从 Blazor 3 1 Preview 2 开始 应该可以防止默认导航行为 https devblogs microsoft com aspnet asp net core updates in net core 3 1 preview

  • 在 azure blob 存储中就地创建 zip 文件

    我将文件存储在 Blob 存储帐户内的一个容器中 我需要在第二个容器中创建一个 zip 文件 其中包含第一个容器中的文件 我有一个使用辅助角色和 DotNetZip 工作的解决方案 但由于 zip 文件的大小最终可能达到 1GB 我担心在进

  • Docker Desktop 不会切换到 Windows 容器（在 Windows 10 上）

    我有 Windows 10 专业版 版本 21H1 BIOS 中已启用虚拟化 Hyper V 正在运行 我已经安装了适用于 Windows 的 Docker Desktop 如上所述here https docs docker com de

  • 如何在多线程应用程序中安全地填充数据并 Refresh() DataGridView？

    我的应用程序有一个 DataGridView 对象和一个 MousePos 类型的列表 MousePos 是一个自定义类 它保存鼠标 X Y 坐标 类型为 Point 和该位置的运行计数 我有一个线程 System Timers Timer

  • SQLAPI++ 的免费替代品？ [关闭]

    Closed 这个问题正在寻求书籍 工具 软件库等的推荐 不满足堆栈溢出指南 help closed questions 目前不接受答案 是否有任何免费 也许是开源 的替代品SQLAPI http www sqlapi com 这个库看起来

  • .NET 和 Mono 之间的开发差异

    我正在研究 Mono 和 NET C 将来当项目开发时我们需要在 Linux 服务器上运行代码 此时我一直在研究 ASP NET MVC 和 Mono 我运行 Ubuntu 发行版 想要开发 Web 应用程序 其他一些开发人员使用 Wind

  • C++ 指针引用混淆

    struct leaf int data leaf l leaf r struct leaf p void tree findparent int n int found leaf parent 这是 BST 的一段代码 我想问一下 为什么

  • 构建 C# MVC 5 站点时项目之间的处理器架构不匹配

    我收到的错误如下 2017 年 4 月 20 日构建 13 23 38 C Windows Microsoft NET Framework v4 0 30319 Microsoft Common targets 1605 5 警告 MSB3

  • 如何编写一个接受 int 或 float 的 C 函数？

    我想用 C 语言创建一个扩展 Python 的函数 该函数可以接受 float 或 int 类型的输入 所以基本上 我想要f 5 and f 5 5 成为可接受的输入 我认为我不能使用if PyArg ParseTuple args i v

  • 将键码转换为相关的显示字符

    在 C Windows Forms 项目中 我有一个不提供 KeyPressed 事件的控件 它是一个 COM 控件 ESRI 映射 它仅提供 KeyUp 和 KeyDown 事件 包含关键事件参数 http msdn microsoft

随机推荐

  • 【Shell】find文件查找

    语法格式 find 路径 选项 操作 选项参数对照表 常用选项 name 查找 etc目录下以conf结尾的文件ind etc nam iname 查找当前目录下文件名为aa的文件 不区分大小写 find iname aa user 查找文

  • [激光原理与应用-69]：激光焊接的10大常见缺陷及解决方法

    激光焊接是一种以高能量密度的激光束作为热源的高效精密焊接方法 如今 激光焊接已广泛应用于各个行业 如 电子零件 汽车制造 航空航天等工业制造领域 但是 在激光焊接的过程中 难免会出现一些缺陷或次品 只有充分了解这些缺陷并学习如何避免它们 才

  • 九轴传感器之测试篇

    关于九轴传感器的数据测试处理

  • CORS与CSRF

    本文首发于我的Github博客 本篇文章介绍了CORS和CSRF的概念 作者前几天在和带佬们聊天的时候把两个概念搞混了 所以才想要了解 简单来说 CORS Cross Origin Resource Sharing 跨域资源分享 是一种机制

  • （1）基础学习——图解pin、pad、port、IO、net 的区别

    本文内容有参考多位博主的博文 综合整理如下 仅做和人学习记录 如有专业性错误还请指正 谢谢 参考1 芯片资料中的pad和pin的区别 imxiangzi的博客 CSDN博客 pin和pad的区别 参考2

  • IntelliJ IDEA 运行卡顿解决方案

    IntelliJ IDEA 运行卡顿解决方案 1 开启IntelliJ IDEA缓慢 想要提升启动速度 则打开D JetBrains IntelliJ IDEA 2020 3 2 bin 依据实际安装路径 目录下对应文件idea64 exe

  • 对csv文件，又get了新的认知

    背景 在数据分析时 有时我们会碰到csv格式文件 需要先进行数据处理 转换成所需要的数据格式 然后才能进行分析 业务侧的同学可能对Excel文件比较熟悉 Excel可以把单个sheet直接保存为csv文件 也可以直接读取csv文件 变成Ex

  • Qt 进程间通信

    Qt进程间通信的方法 TCP IP Local Server Socket 共享内存 D Bus Unix库 QProcess 会话管理 TCP IP 使用套接字的方式 进行通信 之前介绍了 这里就不介绍了 Local Server Soc

  • 用Tensorflow Agents实现强化学习DQN

    在我之前的博客中强化学习笔记 4 深度Q学习 gzroy的博客 CSDN博客 实现了用Tensorflow keras搭建DQN模型 解决小车上山问题 在代码里面 需要自己实现经验回放 采样等过程 比较繁琐 Tensorflow里面有一个a

  • C/C++编程：模板特例

    为什么要引入 单一模板很难兼顾各种情况 为此 C 提供了一种特例机制 对于某个已有模板 可以为某个或者某组模板参数类型另外指定一种变体 以应对原模板无法处理的情况 或者提供更高效的实现方案 这就是模板特例 实例 vector

  • win7 & centos7 双系统安装方法

    1 准备 1 Centos7镜像 官方 https www centos org 阿里镜像64位 http mirrors aliyun com centos 32位 https mirrors aliyun com centos alta

  • 计算机专业考哪些证书含金量高？考到就能加薪吗

    计算机专业要不要考证 考证很重要吗 考哪个好 对于有些人而言 他们可能会有人认为认证就是一张纸 没有太大的用处 看到大家都在考 心里又会产生动摇 还有人会认为考证的价格太高 担心自己没有办法考上白白浪费自己的金钱和时间 或者还有的人在认证的

  • MarkDown中写E-R图、甘特图、饼图的方法

    目录 序 E R 图 E R图的构成 关系的类型 关系的存在性 关系的语法 Mermaid中E R图的简单例子 样例 实体与关系的表示 属性的表示 特殊约束关系的表示 甘特图 Mermaid中甘特图的简单例子 样例 甘特图的标题 子任务的表

  • 如何进阶优秀数据分析师行列？方法、技术与工具，缺一不可！

    更多精彩推荐 请关注我们 入行数据分析师 从来都不是一蹴而就的 好比钓鱼 不是简单地把诱饵放上鱼钩 然后扔到水中 就可以有鱼上钓 方法 技术与工具 缺一不可 什么是举一反三 什么是学以致用 什么是融会贯通 不是靠一味地执著和花时间就可以达到

  • ajax发送post请求报403

    ajax发送post请求报403 检查提交的参数是否和后端接收的参数是否一直

  • 2022最新阿里Java面经，转疯了

    写在前面 最近 很多小伙伴出去面试都被问到了Spring问题 关于Spring 细节点很多 面试官也非常喜欢问一些很细节的技术点 所以 在 Spring 专题中 我们尽量把Spring的每个技术细节说清楚 将透彻 概述 自定义组件要想使用S

  • QCustomplot基本使用(一)

    文章目录 简述 下载 使用 简述 QCustomPlot是一个基于Qt C 的图形库 用于绘制和数据可视化 制作漂亮的2D图 曲线图 趋势图 坐标图 柱状图等 并为实时可视化应用程序提供高性能服务 它没有进一步的依赖关系 并有着良好的文档记

  • 环境配置相关

    anaconda pip无法识别 win10安装了Anaconda之后 未设置环境变量 想用pip命令导入第三方库 在anaconda文件夹下打开命令窗口 输入pip install tensorflow 报错如下 pip 无法将 pip

  • NFT数字藏品平台开发——如何快速搭建搭建数字藏品平台

    2021年可以称为元宇宙年 随着元宇宙概念的兴起 好多人都在关心我们是否可以成功构建元宇宙 显然是可以实现的 2022年年初 NFT在国内的热潮兴起 国内也称之为数字藏品 NFT由于具有不可置换 不可分割的特性 很快在国内掀起一热潮 西西弗

  • 线程间的通讯

    一 为什么需要线程通讯 线程是操作系统调度的最小单位 有自己的栈空间 可以按照既定的代码逐步的执行 但是如果每个线程间都孤立的运行 那就会造资源浪费 所以在现实中 我们需要这些线程间可以按照指定的规则共同完成一件任务 所以这些线程之间就需要

热门标签