Java——线程间的通信

两个线程从初始化时,传入同一个对象,可发生通信。

使用static数据。

传入的参数可作为对象锁,多个线程竞争该对象锁。

1.使用wait/notify函数实现(等待/通知机制

等待/通知机制

wait()使当前执行代码的线程进行等待,将该线程置入“等待队列中(随时唤醒可执行状态)”;调用wait方法前,必须获取到该对象的对象级别的锁(wait/notify方法继承与Object类),即只能在同步方法或者同步块中调用该方法。执行之后,释放对象锁,并且能和其他线程一起竞争该锁。

带参数wait(Long)方法等待某一段时间内是否有线程对锁进行唤醒,如果超过则自动唤醒,long后继续执行程序。

notify()同样需要获取对象锁才能在同步方法或者同步块中调用该方法。该方法会通知可能在等待该对象锁的其他线程,如果有多个则随机挑选一个。执行完notify之后,不会立即释放锁,wait中的线程也不能立即获取锁,要等到执行notify方法的线程将程序执行完,即退出synchronized代码块。notify唤醒其他wait线程,如果对象一直没有调用notify函数,即使对象处于空闲,锁已经释放,wait线程也只能一直处于等待,直到该对象调用notify/notifyAll

notify随机通知一个线程唤醒,进入可执行状态,多次调用则唤醒多个线程。

notifyAll使所有的wait状态线程从等待状态进入可执行状态,此时优先级最高的线程最先执行,也可能随机执行。取决于虚拟机的实现。

 

2.生产者,消费者模式实现

 

 

3.join方法实现

使调用join的线程对象执行完毕run方法中的任务之后,才执行当前线程任务:

public static void main(String[] args){
    try{
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.join();
        Sysotem.out.println("------主线程中的任务-----");
    }catch(Exception e){
    }
}

原本如果主线程中没有myThread.join(),输出函数也许会先于子线程执行完毕;加上join后,主线程将被无限期挂起,直到子线程执行完毕销毁后才继续执行。阻止被插入的线程的执行,先执行插入的线程。

join(Long),设置等待的时间,内部采用wait(Long)实现,具有释放锁的特点,所以调用之后会释放锁。

sleep(Long),也会等待再执行,不会释放锁。

 

4.ThrealLocal实现

ThreadLocal解决每一个线程都能绑定自己的值。存放着每个线程的私有数据。

public static ThreadLocal tl = new ThreadLocal()

tl.get()取值,默认第一次调用没有值返回null。可以继承ThreadLocal类,重写initailValue()方法,返回初始值。

tl.set()存值

哪个线程调用ThreadLocal对象及其函数,则对该线程的数据进行操作。main线程调用,操作main线程数据,若是在ThreadA线程的run中调用,则是操作A线程的数据。

使用InheritableThreadLocal类在让子线程从父线程中获取值,例如在main函数中创建新的进程,新的进程的run函数中调用InheritableThreadLocal对象,get函数获取main线程的数据。

### Java 线程间通信的方法和机制 Java 中的线程间通信是指多个线程通过某种方式共享数据或控制流,从而实现协同工作的过程。以下是几种常见的线程间通信方法及其工作机制。 #### 1. 使用 `wait()` 和 `notify()/notifyAll()` `Object` 类提供了三个用于线程间通信的核心方法:`wait()`、`notify()` 和 `notifyAll()`。这些方法必须在同步上下文中调用(即在 synchronized 块或方法中)。 - **`wait()`**: 当前线程进入等待状态,直到其他线程调用了同一对象上的 `notify()` 或 `notifyAll()` 方法。 - **`notify()`**: 随机唤醒一个正在此对象上等待的单个线程。 - **`notifyAll()`**: 唤醒在此对象上等待的所有线程。 这种方法适用于生产者消费者模式等场景[^1]。 ```java class SharedResource { private int data; private boolean available = false; public synchronized void produce(int value) throws InterruptedException { while (available) { wait(); // 如果资源不可用,则当前线程等待 } data = value; available = true; notifyAll(); // 通知消费线程可以继续运行 } public synchronized int consume() throws InterruptedException { while (!available) { wait(); // 如果资源不可用,则当前线程等待 } available = false; notifyAll(); // 通知生产线程可以继续运行 return data; } } ``` --- #### 2. 使用 `Lock` 和条件变量 除了传统的 `synchronized` 关键字外,还可以使用更高层次的锁机制——`ReentrantLock` 及其关联的条件队列 (`Condition`) 来实现线程间通信。这种方式更加灵活,允许指定不同的条件进行信号传递[^3]。 ```java import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class SharedResourceWithLock { private final Lock lock = new ReentrantLock(); private final Condition condition = lock.newCondition(); private int data; private boolean available = false; public void produce(int value) throws InterruptedException { lock.lock(); try { while (available) { condition.await(); // 生产线程等待 } data = value; available = true; condition.signalAll(); // 唤醒消费线程 } finally { lock.unlock(); } } public int consume() throws InterruptedException { lock.lock(); try { while (!available) { condition.await(); // 消费线程等待 } available = false; condition.signalAll(); // 唤醒生产线程 return data; } finally { lock.unlock(); } } } ``` --- #### 3. 利用阻塞队列 Java 的 `java.util.concurrent` 包提供了一系列高效的线程安全集合类,其中最常用的便是阻塞队列(Blocking Queue),如 `LinkedBlockingQueue` 和 `ArrayBlockingQueue`。这类容器本身实现了生产和消费逻辑中的线程协调功能[^2]。 ```java import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class ProducerConsumerExample { static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); public static class Producer implements Runnable { @Override public void run() { try { for (int i = 0; i < 20; i++) { System.out.println("Producing " + i); queue.put(i); // 自动处理满队列的情况 Thread.sleep(100); } } catch (InterruptedException e) {} } } public static class Consumer implements Runnable { @Override public void run() { try { while (true) { Integer item = queue.take(); // 自动处理空队列的情况 System.out.println("Consumed " + item); if (item == 19) break; // 终止条件 } } catch (InterruptedException e) {} } } public static void main(String[] args) throws Exception { Thread producerThread = new Thread(new Producer()); Thread consumerThread = new Thread(new Consumer()); producerThread.start(); consumerThread.start(); producerThread.join(); consumerThread.join(); } } ``` --- #### 4. 使用原子变量 对于简单的计数器操作或其他轻量级需求,可以直接利用 `AtomicInteger`、`AtomicLong` 等原子类完成无锁化的线程间通信。 ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicCounter { private AtomicInteger counter = new AtomicInteger(0); public int incrementAndGet() { return counter.incrementAndGet(); // 完成自增并返回新值 } public int get() { return counter.get(); // 获取当前值 } } // 测试代码省略... ``` --- #### 5. 使用 `CountDownLatch`, `CyclicBarrier` 和 `Semaphore` 这些工具类分别适合不同类型的线程协作场景: - **`CountDownLatch`**: 让某个线程等待若干事件完成后才继续执行。 - **`CyclicBarrier`**: 多个线程到达屏障后再一起向前推进。 - **`Semaphore`**: 控制同时访问某资源的最大线程数量。 示例代码如下: ```java import java.util.concurrent.CountDownLatch; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { CountDownLatch latch = new CountDownLatch(3); for (int i = 0; i < 3; i++) { new Thread(() -> { System.out.println(Thread.currentThread().getName() + " is done."); latch.countDown(); // 减少倒计数值 }).start(); } latch.await(); // 主线程会一直等到计数归零 System.out.println("All threads have finished their work."); } } ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值