java线程通信总结

最新推荐文章于 2024-07-14 02:44:52 发布
最新推荐文章于 2024-07-14 02:44:52 发布
阅读量530 收藏 1
点赞数
分类专栏： java多线程与并发 文章标签： java 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21225505/article/details/123974394
版权
本文详细介绍了线程的工作原理，包括进程与线程的概念，线程状态的切换，以及Java中四种常见的线程通信方式：volatile、wait/notify、Condition和BlockingQueue。通过实例代码展示了每种通信方式的用法，强调了在多线程环境下确保数据同步和正确通信的重要性。
摘要由CSDN通过智能技术生成

一、线程之间如何工作

  大家都知道计算机的核心是CPU，它承担着计算机所搜的计算任务， 而操作系统负责计算机任务的调度，资源管理与分配。

  进程是一个具有独立功能的程序，是操作系统进行资源分配和调度的基本单位，是应用程序的载体，比如微信、IDEA等运行都属于进程的范畴。进程是任务调度的最小单位，每个进程都有属于自己的一块独立内存，各个进程之间是相互隔离的。线程则是程序执行中一个单一的的顺序控制流程，是程序执行的最小单元，是处理器调度的最小单元。一个进程可以有一个或多个线程，多个线程之间共享进程的内存空间。举个例子，微信能够保证用户刷视频的同时，及时接收好友信息，可以简单理解为微信（进程）拥有俩个执行中的线程。

二、线程状态如何切换

  线程运行过程中会经历创立、运行、暂停、销毁等几个阶段 

  上图为大家展示了线程运行过程中的几种状态，其中wait()方法的作用是使得当前执行代码的线程进入等待（暂停），直到接到notify()方法通知或者被中断为止。需要注意的是，在上述俩个方法，只能在同步方法或者同步代码块中执行，即必须获得对象级别锁

  每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的进程，阻塞队列存储了被阻塞的进程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度；反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。

三、线程间通信

  线程通信的有以下几种

1、共享变量

  第一类：使用volatile关键字实现   示例代码如下：

public class RunThread extends Thread{

	private volatile boolean isRunning = true;
	private void setRunning(boolean isRunning){
		this.isRunning = isRunning;
	}
	
	public void run(){
		System.out.println("进入run方法..");
		int i = 0;
		while(isRunning == true){
			//..
		}
		System.out.println("线程停止");
	}
	
	public static void main(String[] args) throws InterruptedException {
		RunThread rt = new RunThread();
		rt.start();
		Thread.sleep(1000);
		rt.setRunning(false);
		System.out.println("isRunning的值已经被设置了false");
	}
	
}

  不加volatile关键字，while循环不会停止。该关键字使得isRunning对其它进程可见，当其它进程对变量进行修改后，线程会强制执行把共性内存内的变量值重新读取一遍，加载到自身的工作内存中。

但是 volatile关键字不具有同步性，一般只用于多线程的变量读操作，并不能代替synchronize关键字的同步性

  第二类：使用synchronized/wait/notify实现

  对于生产者-消费者问题，有两个要点需要注意：

  第一，在多个同类型线程（多个生产者线程或者消费者线程）的场景中，为防止wait的条件发生变化而导致线程异常终止，我们在阻塞线程被唤醒的同时还必须对wait的条件进行额外的检查，即 使用 while 循环代替 if条件；

  第二，在多个同类型线程（多个生产者线程或者消费者线程）的场景中，为防止生产者(消费者)仅唤醒生产者(消费者)，保证生产者和消费者互相唤醒，需要 使用 notifyAll 替代 notify。

  示例代码如下：

public class Demo1 {

    private final List<Integer> list =new ArrayList<>();

    public static void main(String[] args) {
        Demo1 demo =new Demo1();
        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                   // if(demo.list.size()%2==1){
                    while(demo.list.size()%2==1){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    //demo.list.notify();
                    demo.list.notifyAll();
                }
            }

        }).start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                    //if(demo.list.size()%2==0){
                    while(demo.list.size()%2==0){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    //demo.list.notify();
                    demo.list.notifyAll();
                }
            }
        }).start();
    }
}

输出结果如下：

Thread-0[0]
Thread-1[0, 0]
Thread-0[0, 0, 1]
Thread-1[0, 0, 1, 1]
Thread-0[0, 0, 1, 1, 2]
Thread-1[0, 0, 1, 1, 2, 2]
Thread-0[0, 0, 1, 1, 2, 2, 3]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8]
Thread-0[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9]
Thread-1[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]

  此类通信方式属于等待/通知机制，不同于volatile关键字的实现机制。第一类实现方式是多个线程主动读取一个共享变量，在花费时间读取变量的基础上，加上while等条件判断语句，并不能保证读到的变量是预期结果。

  如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，到等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。

  第三类：使用lock/Condition实现

  相比使用Object的wait()/notify()，使用Condition的await()/signal()这种方式能够更加安全和高效地实现线程间协作。 Condition是个接口，基本的方法就是await()和signal()方法。Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition() 。

  必须要注意的是，Condition 的 await()/signal() 使用都必须在lock保护之内，也就是说，必须在lock.lock()和lock.unlock之间才可以使用。

  示例代码如下：

public class Task {
    private final Lock lock = new ReentrantLock();

    private final Condition addConditon = lock.newCondition();
    private final Condition subConditon = lock.newCondition();

    private volatile int num = 0;
    private List<String> list = new ArrayList<>();

    public void add() {
        for (int i = 0; i < 10; i++) {
            lock.lock();

            try {
                if (list.size() == 10) {
                    addConditon.await();
                }
                num++;
                Thread.sleep(100);
                list.add("add " + num);
                System.out.println("The list size is " + list.size());
                System.out.println("The add thread is " + Thread.currentThread().getName());
                System.out.println("-------------");
                subConditon.signal();

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public void sub() {
        for (int i = 0; i < 10; i++) {
            lock.lock();

            try {

                if (list.size() == 0) {
                    subConditon.await();
                }
                num--;
                Thread.sleep(100);
                list.remove(0);
                System.out.println("The list size is " + list.size());
                System.out.println("The sub thread is " + Thread.currentThread().getName());
                System.out.println("-------------");
                addConditon.signal();

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }


    public static void main(String[] args) {
        Task task = new Task();
        new Thread(task::add).start();
        new Thread(task::sub).start();
    }
}

输出结果如下：

The list size is 1
The add thread is Thread-0
-------------
The list size is 2
The add thread is Thread-0
-------------
The list size is 3
The add thread is Thread-0
-------------
The list size is 4
The add thread is Thread-0
-------------
The list size is 5
The add thread is Thread-0
-------------
The list size is 6
The add thread is Thread-0
-------------
The list size is 5
The sub thread is Thread-1
-------------
The list size is 6
The add thread is Thread-0
-------------
The list size is 7
The add thread is Thread-0
-------------
The list size is 8
The add thread is Thread-0
-------------
The list size is 9
The add thread is Thread-0
-------------
The list size is 8
The sub thread is Thread-1
-------------
The list size is 7
The sub thread is Thread-1
-------------
The list size is 6
The sub thread is Thread-1
-------------
The list size is 5
The sub thread is Thread-1
-------------
The list size is 4
The sub thread is Thread-1
-------------
The list size is 3
The sub thread is Thread-1
-------------
The list size is 2
The sub thread is Thread-1
-------------
The list size is 1
The sub thread is Thread-1
-------------
The list size is 0
The sub thread is Thread-1
-------------

  使用Condition往往比使用传统的通知等待机制(Object的wait()/notify())要更灵活、高效，也可以使用多个Condition实现通知部分线程

  第四类：使用PipedInputStream/PipedOutputStream实现

  PipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信。一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。

  PipedOutputStream可以向管道中写入数据，PipedIntputStream可以读取PipedOutputStream向管道中写入的数据，这两个类主要用来完成线程之间的通信。 PipedInputStream和PipedOutputStream的实现原理类似于”生产者-消费者”原理，PipedOutputStream是生产者，PipedInputStream是消费者。


public class Test {
    public static void main(String[] args) {
        try {
            PipedInputStream inputStream = new PipedInputStream();
            PipedOutputStream outputStream = new PipedOutputStream();
 
            // inputStream.connect(outputStream);   // 效果相同
            outputStream.connect(inputStream);
 
            ThreadRead threadRead = new ThreadRead( inputStream);
            threadRead.start();
 
            Thread.sleep(2000);
 
            ThreadWrite threadWrite = new ThreadWrite( outputStream);
            threadWrite.start();
 
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//读线程


class ThreadRead  extends Thread {

  private PipedInputStream input;

  public ThreadRead ( PipedInputStream input) {
      super();
      this.input = input;
  }

  public void readMethod(PipedInputStream input) {
      try {
          System.out.println("readMethod begin  :");
          byte[] byteArray = new byte[20];
          int readLength = input.read(byteArray);
          while (readLength != -1) {
              String newData = new String(byteArray, 0, readLength);
              System.out.print(newData);
              readLength = input.read(byteArray);
          }
          System.out.println();
          System.out.println("readMethod end  :");
          input.close();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

  @Override
  public void run() {
      this.readMethod(input);
  }
}

//写线程
class ThreadWrite extends Thread {

  private PipedOutputStream out;

  public ThreadWrite( PipedOutputStream out) {
      super();
      this.out = out;
  }

  public void writeMethod(PipedOutputStream out) {
      try {
          System.out.println("writeMethod begin :");
          for (int i = 0; i < 30; i++) {
              String outData = "" + (i + 1);
              out.write(outData.getBytes());
              System.out.print(outData);
          }
          System.out.println();
          System.out.println("writeMethod end :");
          out.close();
      } catch (IOException e) {
          e.printStackTrace();
      }
  }

  @Override
  public void run() {
      this.writeMethod(out);
  }
}

输出结果如下：

readMethod begin  :
writeMethod begin :
123456789101112131415161718192021222324252627282930
writeMethod end :
123456789101112131415161718192021222324252627282930
readMethod end  :

  第五类：使用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：数组阻塞队列，规定大小，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
  • LinkedBlockingQueue：链阻塞队列，大小不定，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的。
  • PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
  • SynchronousQueue：特殊的BlockingQueue，它的内部同时只能够容纳单个元素，对其的操作必须是放和取交替完成的。
  • DelayQueue：延迟队列，注入其中的元素必须实现 java.util.concurrent.Delayed 接口
public class BlockingQueueDemo {

    public static void main(String[] args) {
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
        //读线程
        new Thread(() -> {
            int i =0;
            while (true) {
                try {
                    String item = queue.take();
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    i++;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //写线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    String item = "go"+i;
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    queue.put(item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

以上内容参考文章：

进程与线程 - 浅浅念 - 博客园
Java中的ThreadLocal详解 - 夏末秋涼 - 博客园
java线程间通讯的几种方式_顽石九变的博客-CSDN博客_java线程间的通信方式三种
Java多线程编程（三）线程间通信 - BigJunOba - 博客园
JAVA线程通信详解_抽离的心的博客-CSDN博客_java线程通信

 

java实现线程通信的几种方式
congge
05-30 5万+
前言 在多线程的世界里，线程与线程之间的交互无处不在，只不过在平时的开发过程中，大多数情况下，我们都在单线程的模式下进行编码，即使有，也直接借助框架自身的机制实现了，其实线程之间的通信在JDK中是一个比较深的问题，比如大家熟知的消息中间件的实现，从某种角度上讲，就借助了多线程通信的思想，下面总结了JDK中常用的几种实现线程通信的方式，提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问，synchronized是对共享资源加锁使用的，怎么和线程通信扯在一起呢？这里纠正一个小小的偏见，也是
Java中线程用法总结
09-03
本文将深入探讨Java线程的常见使用技巧。 首先，线程是操作系统的基本调度单元，它们共享同一进程的资源，例如内存和文件句柄。每个线程都有自己的程序计数器（PC）、栈空间以及局部变量，使得它们可以在同一进程中...
java线程的通信_java线程之间的通信
weixin_34861332的博客
02-20 96
1.常用的方法sleep() 该线程进入等待状态,不释放锁wait()该线程进入等待状态,释放锁notify()随机唤醒一个线程notifyAll()唤醒全部线程getName()获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)setName(String name)设置线程名称currentThread()返回当前正在执行的线程对象引用sleep(Long time...
【Java 基础篇】Java 线程通信详解
繁依Fanyi的博客
09-20 785
线程通信是指多个线程之间通过共享内存或其他通信机制来传递信息、同步动作或协作完成任务的过程。线程通信的核心目标是确保线程能够按照预定的顺序执行，并且能够安全地访问共享资源。线程同步：确保多个线程之间的操作按照一定的顺序执行，避免竞态条件和数据不一致性问题。线程等待：使线程能够等待某个条件的满足，以便在条件满足时再继续执行。线程通知：使线程能够通知其他线程某个条件已经满足，以便其他线程可以继续执行。线程唤醒：使等待状态的线程被唤醒，以便它们可以继续执行。
深入理解Java线程间通信
BASK2311的博客
11-25 1006
合理的使用Java多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要我们掌握Java线程的通信方式。本文将介绍Java线程之间的几种通信原理。
JAVA线程通信详解
不二的博客
11-19 360
一、概述 线程与线程之间不是相互独立的个体，它们彼此之间需要相互通信和协作，最典型的例子就是生产者-消费者问题：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此一般情况...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
Java多线程学习总结
09-14
总的来说，Java多线程技术不仅涉及到线程的创建和管理，还包括线程间通信和同步，这些都是Java程序员需要掌握的重要技能。理解和熟练应用这些知识，可以帮助开发者设计出高效、稳定的并发程序。
Java多线程知识点总结
08-19
在多线程编程中，线程间的同步和通信是需要特别注意的地方。Java提供了多种机制来保证线程安全，比如使用synchronized关键字来同步方法或代码块，实现线程之间的同步。当一个线程试图进入一个已经被另一个线程持有的...
java线程大总结.pdf
10-04
Java线程管理是Java编程中不可或缺的一部分，尤其在并发编程中起到关键作用。在这个大总结中，主要讨论了两种线程同步机制：信号量（Semaphore）和阻塞队列（BlockingQueue），以及Java 6引入的阻塞栈...
JAVA线程之间的通信
qq_42682991的博客
11-28 4214
线程通信涉及到的三个方法： （1）wait():一旦执行此方法当前线程进入阻塞状态，并释放同步监视器 （2）notify()：一旦执行此方法就会唤醒被wait的另一个线程。如果存在多个被wait的线程，唤醒优先级高的线程。 （3）notifyAll()：一旦执行此方法就会唤醒所有被wait的线程 说明： （1）wait()、notify()、notifyAll()三个方法必须在同步代码块或同步方法里面使用 （2）wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步.
【Java学习】多线程：线程创建、线程状态、线程同步、线程通信全总结
胡毛毛的博客
11-14 1243
目录1、基本概念2、线程创建2.1、 继承 Thread 类（重点）Thread API2.2、 实现Runnable接口（重点）Runnable接口API以上两种方式的比较：初识并发问题——买火车票龟兔赛跑问题：img2.3、 实现Callable接口（了解）2.4、 Lambda表达式2.5、 静态代理模式img3、线程状态3.1、 线程的一些常用方法常用方法——API3.2、 线程休眠——sleep()sleep——APIimg3.3、 线程礼让——yield()yield()——API3.4、 合并
Java中的线程通信详解
最新发布
weixin_42303107的博客
07-14 493
Java中的线程通信详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在多线程编程中，线程之间的通信是一个重要且复杂的主题。为了确保多线程程序的正确性和效率，线程需要能够互相通信并协调工作。Java 提供了多种方式来实现线程间的通信，如 wait()、notify()、notifyAll...
java 线程通讯,Java线程通信详解
weixin_29075633的博客
03-14 84
线程通信用来保证线程协调运行，一般在做线程同步的时候才需要考虑线程通信的问题。1、传统的线程通信通常利用Objeclt类提供的三个方法：wait() 导致当前线程等待，并释放该同步监视器的锁定，直到其它线程调用该同步监视器的notify()或者notifyAll()方法唤醒线程。notify()，唤醒在此同步监视器上等待的线程，如果有多个会任意选择一个唤醒notifyAll() 唤醒在此同步监视器...
线程间通信知识总结
Zenrym的博客
08-08 194
文章目录为什么要进行线程间通信线程间通信方式 为什么要进行线程间通信 多个线程并发执行时，在默认的情况下，CPU是随机切换线程的，而有时我们需要让CPU按照我们的期望来执行线程，此时就需要线程之间协调通信 线程间通信方式 1.休眠唤醒的方式，如：Object中的wait、notify、notifyAll和Condition中的await、signal、signalAll 2.CountDownLatch，用于某个线程A等待一个或多个其他线程执行完毕后，线程A才执行 3.CyclicBarrier,一组线程等
线程通信学习小结
weixin_45745355的博客
10-17 205
线程通信浅析 java支持多线程执行，线程之间需要进行数据交互，消息传输，必然会存在线程间的通信。例如：线程自旋，线程等待，锁，线程唤醒等。下面介绍几种线程通信api说明 1、suspend/resume组合 此组合以及被jdk废弃掉。 原因：此通信api很容易导致线程通信的死锁。 死锁示例共两个代表示例： a) 两个线程同时使用同一个对象锁，相互持有锁时，就会出现死锁情况。 b) 执行resu...
Java多线程总结
weixin_42596778的博客
01-25 460
1.实现线程的三种方式: 继承Thread类（无返回值）： public class ThreadTest { /** * 继承Thread类 */ public static class MyThread extends Thread { @Override public void run() { System.out.println("This is child thread"); }
Java多线程——线程通信
qq_61897054的博客
04-05 1057
线程通信线程通信概念涉及方法线程死锁 线程通信概念 在多线程任务中，某一个线程的执行结果是另一个线程需要的资源，这样，我们就需要使两个线程的执行顺序做调整，并且使其资源能够流通。 涉及方法 wait()：一旦执行此方法，使当前线程进入阻塞状态，并释放同步监视器 notify()：一旦执行此方法，就会唤醒被wait()的一个线程，若有多个线程，则唤醒优先级高的 notifyAll()：一旦执行此方法，唤醒所有被wait()的线程。 线程通信：使用两个线程交替打印 1~100 class Number im
Java多线程通信机制
yzx41099296的专栏
12-26 2741
Java提供了3个非常重要的方法来巧妙地解决线程间的通信问题。这3个方法分别是：wait()、notify()和notifyAll()。它们都是Object类的最终方法，因此每一个类都默认拥有它们。     虽然所有的类都默认拥有这3个方法，但是只有在synchronized关键字作用的范围内，并且是同一个同步问题中搭配使用这3个方法时才有实际的意义。 这些方法在Object类中声明的语法格式
Java线程通信详解：等待通知与同步机制
总结来说，Java线程通信的关键在于理解并熟练运用`wait()`、`notify()`和`notifyAll()`等方法，以及它们在多线程并发控制中的作用。掌握这些原理有助于编写出健壮且高效的并发程序，避免常见的并发问题，提升系统的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

皓月星辰_w

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值