JAVA线程间通信的几种方式

最新推荐文章于 2024-08-21 15:17:57 发布
最新推荐文章于 2024-08-21 15:17:57 发布
阅读量4.3w 收藏 180
点赞数 27
分类专栏： java 面试宝典 文章标签： 通信 多线程
今天在群里面看到一个很有意思的面试题：
“编写两个线程，一个线程打印1~25，另一个线程打印字母A~Z，打印顺序为12A34B56C……5152Z，要求使用线程间的通信。”

这是一道非常好的面试题，非常能彰显被面者关于多线程的功力，一下子就勾起了我的兴趣。这里抛砖引玉，给出7种想到的解法。

通用代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Edison Xu on 2017/3/2.
 */
public enum Helper {

    instance;

    private static final ExecutorService tPool = Executors.newFixedThreadPool(2);

    public static String[] buildNoArr(int max) {
        String[] noArr = new String[max];
        for(int i=0;i<max;i++){
            noArr[i] = Integer.toString(i+1);
        }
        return noArr;
    }

    public static String[] buildCharArr(int max) {
        String[] charArr = new String[max];
        int tmp = 65;
        for(int i=0;i<max;i++){
            charArr[i] = String.valueOf((char)(tmp+i));
        }
        return charArr;
    }

    public static void print(String... input){
        if(input==null)
            return;
        for(String each:input){
            System.out.print(each);
        }
    }

    public void run(Runnable r){
        tPool.submit(r);
    }

    public void shutdown(){
        tPool.shutdown();
    }

}

1. 第一种解法，包含多种小的不同实现方式，但一个共同点就是靠一个共享变量来做控制；

a. 利用最基本的synchronized、notify、wait：

public class MethodOne {
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                try {
                    for (int i = 0; i < arr.length; i=i+2) {
                        synchronized (threadToGo) {
                            while (threadToGo.value == 2)
                                threadToGo.wait();
                            Helper.print(arr[i], arr[i + 1]);
                            threadToGo.value = 2;
                            threadToGo.notify();
                        }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                try {
                    for (int i = 0; i < arr.length; i++) {
                        synchronized (threadToGo) {
                            while (threadToGo.value == 1)
                                threadToGo.wait();
                            Helper.print(arr[i]);
                            threadToGo.value = 1;
                            threadToGo.notify();
                        }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }
    class ThreadToGo {
        int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
        MethodOne one = new MethodOne();
        Helper.instance.run(one.newThreadOne());
        Helper.instance.run(one.newThreadTwo());
        Helper.instance.shutdown();
    }
}

b. 利用Lock和Condition：

public class MethodTwo {
    private Lock lock = new ReentrantLock(true);
    private Condition condition = lock.newCondition();
    private final ThreadToGo threadToGo = new ThreadToGo();
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    try {
                        lock.lock();
                        while(threadToGo.value == 2)
                            condition.await();
                        Helper.print(arr[i], arr[i + 1]);
                        threadToGo.value = 2;
                        condition.signal();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    try {
                        lock.lock();
                        while(threadToGo.value == 1)
                            condition.await();
                        Helper.print(arr[i]);
                        threadToGo.value = 1;
                        condition.signal();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        };
    }
    class ThreadToGo {
        int value = 1;
    }
    public static void main(String args[]) throws InterruptedException {
        MethodTwo two = new MethodTwo();
        Helper.instance.run(two.newThreadOne());
        Helper.instance.run(two.newThreadTwo());
        Helper.instance.shutdown();
    }
}
c. 利用volatile：
volatile 修饰的变量值直接存在main memory里面，子线程对该变量的读写直接写入main memory，而不是像其它变量一样在local thread里面产生一份copy。 volatile 能保证所修饰的变量对于多个线程可见性，即只要被修改，其它线程读到的一定是最新的值。 
public class MethodThree {
    private volatile ThreadToGo threadToGo = new ThreadToGo();
    class ThreadToGo {
        int value = 1;
    }
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    while(threadToGo.value==2){}
                    Helper.print(arr[i], arr[i + 1]);
                    threadToGo.value=2;
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    while(threadToGo.value==1){}
                    Helper.print(arr[i]);
                    threadToGo.value=1;
                }
            }
        };
    }
    public static void main(String args[]) throws InterruptedException {
        MethodThree three = new MethodThree();
        Helper.instance.run(three.newThreadOne());
        Helper.instance.run(three.newThreadTwo());
        Helper.instance.shutdown();
    }
}

d. 利用AtomicInteger：

public class MethodFive {
    private AtomicInteger threadToGo = new AtomicInteger(1);
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    while(threadToGo.get()==2){}
                    Helper.print(arr[i], arr[i + 1]);
                    threadToGo.set(2);
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    while(threadToGo.get()==1){}
                    Helper.print(arr[i]);
                    threadToGo.set(1);
                }
            }
        };
    }
    public static void main(String args[]) throws InterruptedException {
        MethodFive five = new MethodFive();
        Helper.instance.run(five.newThreadOne());
        Helper.instance.run(five.newThreadTwo());
        Helper.instance.shutdown();
    }
}

2. 第二种解法，是利用CyclicBarrierAPI；

CyclicBarrier可以实现让一组线程在全部到达Barrier时(执行await())，再一起同时执行，并且所有线程释放后，还能复用它,即为Cyclic。
CyclicBarrier类提供两个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
public class MethodFour{
      private final CyclicBarrier barrier;
      private final List<String> list;
      public MethodFour() {
          list = Collections.synchronizedList(new ArrayList<String>());
          barrier = new CyclicBarrier(2,newBarrierAction());
      }
      public Runnable newThreadOne() {
          final String[] inputArr = Helper.buildNoArr(52);
          return new Runnable() {
              private String[] arr = inputArr;
              public void run() {
                  for (int i = 0, j=0; i < arr.length; i=i+2,j++) {
                      try {
                          list.add(arr[i]);
                          list.add(arr[i+1]);
                          barrier.await();
                      } catch (InterruptedException | BrokenBarrierException e) {
                          e.printStackTrace();
                      }
                  }
              }
          };
      }
      public Runnable newThreadTwo() {
          final String[] inputArr = Helper.buildCharArr(26);
          return new Runnable() {
              private String[] arr = inputArr;
              public void run() {
                  for (int i = 0; i < arr.length; i++) {
                      try {
                          list.add(arr[i]);
                          barrier.await();
                      } catch (InterruptedException | BrokenBarrierException e) {
                          e.printStackTrace();
                      }
                  }
              }
          };
      }
      private Runnable newBarrierAction(){
          return new Runnable() {
              @Override
              public void run() {
                  Collections.sort(list);
                  list.forEach(c->System.out.print(c));
                  list.clear();
              }
          };
      }
      public static void main(String args[]){
          MethodFour four = new MethodFour();
          Helper.instance.run(four.newThreadOne());
          Helper.instance.run(four.newThreadTwo());
          Helper.instance.shutdown();
      }
}
这里多说一点，这个API其实还是利用lock和condition，无非是多个线程去争抢CyclicBarrier的instance的lock罢了，最终barrierAction执行时，是在抢到CyclicBarrierinstance的那个线程上执行的。

3. 第三种解法，是利用PipedInputStreamAPI；

这里用流在两个线程间通信，但是Java中的Stream是单向的，所以在两个线程中分别建了一个input和output。这显然是一种很搓的方式，不过也算是一种通信方式吧……-_-T，执行的时候那种速度简直。。。请不要BS我。 
public class MethodSix {
    private final PipedInputStream inputStream1;
    private final PipedOutputStream outputStream1;
    private final PipedInputStream inputStream2;
    private final PipedOutputStream outputStream2;
    private final byte[] MSG;
    public MethodSix() {
        inputStream1 = new PipedInputStream();
        outputStream1 = new PipedOutputStream();
        inputStream2 = new PipedInputStream();
        outputStream2 = new PipedOutputStream();
        MSG = "Go".getBytes();
        try {
            inputStream1.connect(outputStream2);
            inputStream2.connect(outputStream1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void shutdown() throws IOException {
        inputStream1.close();
        inputStream2.close();
        outputStream1.close();
        outputStream2.close();
    }
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            private PipedInputStream in = inputStream1;
            private PipedOutputStream out = outputStream1;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    Helper.print(arr[i], arr[i + 1]);
                    try {
                        out.write(MSG);
                        byte[] inArr = new byte[2];
                        in.read(inArr);
                        while(true){
                            if("Go".equals(new String(inArr)))
                                break;
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            private PipedInputStream in = inputStream2;
            private PipedOutputStream out = outputStream2;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    try {
                        byte[] inArr = new byte[2];
                        in.read(inArr);
                        while(true){
                            if("Go".equals(new String(inArr)))
                                break;
                        }
                        Helper.print(arr[i]);
                        out.write(MSG);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
    public static void main(String args[]) throws IOException {
        MethodSix six = new MethodSix();
        Helper.instance.run(six.newThreadOne());
        Helper.instance.run(six.newThreadTwo());
        Helper.instance.shutdown();
        six.shutdown();
    }

4. 第四种解法，是利用BlockingQueue；

顺便总结下BlockingQueue的一些内容。
BlockingQueue定义的常用方法如下:

  • add(Object)：把Object加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
  • offer(Object)：表示如果可能的话，将Object加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
  • put(Object)：把Object加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
  • poll(time)：获取并删除BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。当不传入time值时，立刻返回。
  • peek()：立刻获取BlockingQueue里排在首位的对象，但不从队列里删除，如果队列为空，则返回null。
  • take()：获取并删除BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。

BlockingQueue有四个具体的实现类：

  • ArrayBlockingQueue：规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
  • LinkedBlockingQueue：大小不定的BlockingQueue，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的。
  • PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
  • SynchronousQueue：特殊的BlockingQueue，对其的操作必须是放和取交替完成的。

这里我用了两种玩法：

  • 一种是共享一个queue，根据peek和poll的不同来实现；
  • 第二种是两个queue，利用take()会自动阻塞来实现。
public class MethodSeven {
    private final LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
    public Runnable newThreadOne() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    Helper.print(arr[i], arr[i + 1]);
                    queue.offer("TwoToGo");
                    while(!"OneToGo".equals(queue.peek())){}
                    queue.poll();
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    while(!"TwoToGo".equals(queue.peek())){}
                    queue.poll();
                    Helper.print(arr[i]);
                    queue.offer("OneToGo");
                }
            }
        };
    }
    private final LinkedBlockingQueue<String> queue1 = new LinkedBlockingQueue<>();
    private final LinkedBlockingQueue<String> queue2 = new LinkedBlockingQueue<>();
    public Runnable newThreadThree() {
        final String[] inputArr = Helper.buildNoArr(52);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i=i+2) {
                    Helper.print(arr[i], arr[i + 1]);
                    try {
                        queue2.put("TwoToGo");
                        queue1.take();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
    public Runnable newThreadFour() {
        final String[] inputArr = Helper.buildCharArr(26);
        return new Runnable() {
            private String[] arr = inputArr;
            public void run() {
                for (int i = 0; i < arr.length; i++) {
                    try {
                        queue2.take();
                        Helper.print(arr[i]);
                        queue1.put("OneToGo");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
    public static void main(String args[]) throws InterruptedException {
        MethodSeven seven = new MethodSeven();
        Helper.instance.run(seven.newThreadOne());
        Helper.instance.run(seven.newThreadTwo());
        Thread.sleep(2000);
        System.out.println("");
        Helper.instance.run(seven.newThreadThree());
        Helper.instance.run(seven.newThreadFour());
        Helper.instance.shutdown();
    }

原文链接： http://edisonxu.org/2017/03/02/java-thread-communication.html






_calm
关注
专栏目录
Java多线程：线程间通信方式
流楚丶格念的博客
11-08 2039
这三个方法都是Condition接口中的方法，该接口是在Java 1.5中出现的，它用来替代传统的wait+notify实现线程间的协作，它的使用依赖于 Lock。反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。案例步骤：通信是在不同线程间的通信，一个线程处于wait状态阻塞等待被唤醒，另一个线程通过notify或者notifyAll唤醒，当前的唤醒操作必须是作用与同一个对象，注意在进行唤醒和阻塞时必须要加锁的，加锁需要使用synchronized关键字。程序没有结束，他会一直读取阻塞队列。
java实现线程通信的几种方式
热门推荐
congge
05-30 5万+
前言 在多线程的世界里，线程与线程之间的交互无处不在，只不过在平时的开发过程中，大多数情况下，我们都在单线程的模式下进行编码，即使有，也直接借助框架自身的机制实现了，其实线程之间的通信在JDK中是一个比较深的问题，比如大家熟知的消息中间件的实现，从某种角度上讲，就借助了多线程通信的思想，下面总结了JDK中常用的几种实现线程通信的方式，提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问，synchronized是对共享资源加锁使用的，怎么和线程通信扯在一起呢？这里纠正一个小小的偏见，也是
Java实现线程间的通信的五种方式
Meiko记录
07-06 3029
如何使两个线程按顺序执行？ 假设有两个线程：线程A和线程B。两个线程都可以依次打印三个数字（1-3）。让我们看一下代码： private static void demo1() { Thread A = new Thread(new Runnable() { @Override public void run() { printNumber("A"); } }); Thread B = new Thre..
java线程池详解
最新发布
weixin_62801797的博客
08-21 923
抛出来拒绝新任务的处理。：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果你的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。：不处理新任务，直接丢弃掉。：此策略将丢弃最早的未处理的任务请求。举个例子：Spring 通过或者我们直接通过的构造函数创建线程池的时候，当我们不指定拒绝策略来配置线程池的时候，默认使用的是。
java 线程通信的两种方法
yuyi_000的博客
07-29 395
先讲如何通信： 再讲 如何 同步。网上的代码是有问题的。我注释了出来。 第一 。\线程 共用 一个 稀缺变量： 1、 继承至 thread 类 public class Innersharethread { public static void main(String[] args) { Mythread mythread =new Mythread(); myt
Java多线程之间的通信方式
weixin_49698553的博客
07-06 3312
在Java中线程通信主要有以下三种方式：如果线程之间采用synchronized来保证线程安全，则可以利用wait()、notify()、notifyAll()来实现线程通信。这三个方法都不是Thread类中所声明的方法，而是Object类中声明的方法。原因是每个对象都拥有锁，所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作。并且因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。另外，这三个方法都是本地方法，并且被final修饰，无法被重写。wait()方法可以让当前线程释放对
【Java多线程】你知道实现Java线程间通信有多少种方法吗？
aaa_hao的博客
03-24 4248
文章目录1. 锁与同步2. 等待/通知机制3. 信号量4. 管道5. 其它通信相关5.1 join() 方法5.2 sleep() 方法sleep() 与 wait() 的区别5.3 ThreadLocal 类5.4 InheritableThreadLocal 合理地使用 Java 多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要掌握 Java 线程的通信方式。下文将介绍 Java 线程之间的几种通信机制和原理。 1. 锁
Java线程间的通信方式详解
09-02
Java线程间的通信是多线程编程中的重要概念，它涉及到如何协调多个并发执行的线程，确保数据的一致性和正确性。本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java...
线程的几种控制方式以及线程间的几种通信方式
10-29
4. **线程间通信**：线程间通信允许线程之间交换信息，Java提供了多种机制，如`wait()`, `notify()`, `notifyAll()`，Python中则有`Condition`对象。 5. **线程休眠**：Java的`Thread.sleep()`方法可以让线程暂停...
java线程通信的几种方式_Java线程间通信的几种方式
weixin_30018111的博客
02-17 425
文章目录一、使用同一个共享变量控制Synchronized、wait、notifypublic class Demo1 {private final List list =new ArrayList<>();public static void main(String[] args) {Demo1 demo =new Demo1();new Thread(()->{for (in...
java 线程间通信的几种实现方式
希望不晚
06-25 185
假设有一段字符串“1A2B3C4D”, 启动两个线程，线程交替打印字符串中的某个字符。方法三：使用ReentrantLock、Condition实现。方法一：使用wait、notify的方式实现。方法二：使用LockSupport工具类实现。以上三种方法，是目前我想到的。
【Java进阶】Java线程间通讯的几种方式
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-06 2万+
一、使用同一个共享变量控制 Synchronized、wait、notifyLock、Condition利用volatile利用AtomicInteger二、PipedInputStream、PipedOutputStream 三、利用BlockingQueue
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 6024
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java线程通信的几种方式
Admans的专栏
06-29 4542
有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 Object 类提供了线程间通信的方法：wait()、no
Java中的线程通信的几种方式
u013749113的博客
05-17 1583
Java中提供了多种方式来实现线程间通信，其中最常见的方式包括synchronized关键字、wait()和notify()方法、CountDownLatch类、Semaphore类和BlockingQueue类。这些方式都可以用来实现线程之间的互斥、同步、数据共享和通信。选择哪种方式取决于具体的应用场景和需求。在使用这些方式时，需要注意线程安全和死锁等问题，以确保程序的正确性和健壮性。
Java线程之间通信方式
赵广陆
09-09 2185
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
Java - 线程间的通信方式
m0_65228708的博客
12-10 1443
线程通信的方式 共享内存 消息传递 管道输入/输出流
线程间通信的几种方式
09-01
线程间通信有多种方式可以实现。其中一种方式是使用共享变量，在不同的线程之间共享数据。通过读写共享变量来进行线程间的通信。这种方式需要注意线程安全性和同步机制，以避免数据竞争和不一致的问题。 另一种方式是使用线程同步机制，例如使用锁机制来实现线程间的通信。锁可以用来保护共享资源，确保在一个线程访问共享资源的同时，其他线程不能同时访问该资源。通过获取锁和释放锁的方式来实现线程间的同步和通信。 还有一种方式是使用线程间的阻塞和唤醒机制。通过在线程中使用等待和通知的方式来实现线程间的通信。当一个线程需要等待某些条件满足时，它可以调用等待方法进入等待状态，而其他线程在某些条件满足时可以调用通知方法来唤醒等待的线程。这种方式适用于线程间存在依赖关系的情况下。 此外，还可以使用信号量、管道、消息队列等方式来实现线程间的通信。每种方式都有其适用的场景和特点，根据具体的需求选择合适的方式进行线程间的通信。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Java线程间的通信方式详解](https://download.csdn.net/download/weixin_38649315/12797496)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [线程间的通信方法](https://blog.csdn.net/liubing8609/article/details/81700284)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值