同步模式之犹豫模式Balking

淩亂°似流年 2024-03-16 13:52 115阅读 0赞

tip: 作为程序员一定学习编程之道，一定要对代码的编写有追求，不能实现就完事了。我们应该让自己写的代码更加优雅，即使这会费时费力。

推荐：**[体系化学习Java（Java面试专题）][Java_Java]**

#### 文章目录 ####

*  一、同步模式之犹豫模式Balking
 *  二、代码样例
 *  三、优缺点

## 一、同步模式之犹豫模式Balking ##

同步模式之犹豫模式Balking是一种多线程编程中的同步模式。在该模式中，线程在执行操作之前会先检查某些条件，如果发现在执行操作之前会导致某些不良后果，则该线程会放弃执行该操作，避免出现问题。

犹豫模式Balking通常用于避免竞态条件和死锁问题。在多线程编程中，由于多个线程同时访问共享资源，可能会导致数据不一致或者死锁等问题。因此，在访问共享资源之前，线程需要先检查某些条件，以确保它们不会破坏共享资源的状态。

例如，如果多个线程都需要向一个队列中添加元素，那么在添加元素之前，每个线程都需要检查队列的状态以确保它们不会重复添加元素。如果某个线程发现队列已经满了，那么它就会放弃添加元素的操作，避免出现死锁或者数据不一致的问题。

总之，同步模式之犹豫模式Balking是一种非常实用的同步模式，可以有效地避免多线程编程中的竞态条件和死锁问题。

## 二、代码样例 ##

下面是一个实现的同步模式之犹豫模式Balking的例子：  
假设有一个多线程程序需要向一个队列中添加元素，但是在添加元素之前需要检查队列是否已经满了。如果队列已经满了，则当前线程需要等待一段时间后再尝试添加元素。

package com.pany.camp.thread.balking;
    
    import cn.hutool.core.thread.ThreadUtil;
    
    import java.util.Queue;
    import java.util.concurrent.ConcurrentLinkedQueue;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class BalkingExample {
        
        private final Queue<String> queue = new ConcurrentLinkedQueue<>();
        private final Lock lock = new ReentrantLock();
    
        public void add(String item) throws InterruptedException {
        
            if (lock.tryLock(1, TimeUnit.SECONDS)) {
        
                try {
        
                    if (queue.size() < 5) {
        
                        queue.add(item);
                    } else {
        
                        System.out.println("Queue is full. Waiting...");
                        Thread.sleep(1000);
                        add(item);
                    }
                } finally {
        
                    lock.unlock();
                }
            } else {
        
                System.out.println("Failed to acquire lock. Waiting...");
                Thread.sleep(1000);
                add(item);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            BalkingExample example = new BalkingExample();
            Thread[] threads = new Thread[10];
            for (int i = 0; i < 10; i++) {
        
                threads[i] = new Thread(() -> {
        
                    try {
        
                        example.add("Thread " + Thread.currentThread().getId());
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                });
                threads[i].start();
            }
            new Thread(() -> {
        
                ThreadUtil.sleep(1000);
                System.out.println(example.queue);
            }).start();
        }
    }

![在这里插入图片描述][8b41a4f4d27f4fd39782da2e4a4216d7.png]

## 三、优缺点 ##

犹豫模式Balking虽然可以解决一些同步问题，但也存在一些缺点：

1.  可能导致死锁：如果一个线程一直在等待某个条件满足，而其他线程也在等待该线程释放锁，这可能会导致死锁。
2.  可能导致数据丢失：如果一个线程在等待某个条件满足时被中断或终止，那么可能会导致数据丢失。
3.  可能导致性能问题：如果一个线程一直在等待某个条件满足，那么其他线程可能会被阻塞，从而导致性能问题。  
    因此，在使用犹豫模式Balking时，需要仔细考虑其适用性，并确保在使用时避免以上缺点的出现。

[Java_Java]: https://blog.csdn.net/qq_37967783/article/details/130940512
[8b41a4f4d27f4fd39782da2e4a4216d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5d074ee19529438f8b126af94f4801a2.png