Guarded Suspension设计模式

Posted moris5013

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Guarded Suspension设计模式相关的知识,希望对你有一定的参考价值。

Guarded Suspension 设计模式可以保证,当线程在访问某个对象时,发现条件不满足,就挂起等待条件满足时再次访问
public class GuardedSuspensionQueue {
    
    // 定义存放Integer类型的queue
    private final LinkedList<String> queue = new LinkedList<String>();

    // 定义queue的最大容量为5
    private  final int LIMIT = 5;

    public  static final Random random = new Random(System.currentTimeMillis());

    // 往queue中插入数据,如果queue中的元素超过了最大容量,则会陷入阻塞
    public void offer(String data) {
        synchronized (this) {
            // 判断queue的当前元素是否超过了LIMIT
            while (queue.size() >= LIMIT) {
                // 挂起当前线程,使其陷入阻塞
                System.out.println("向queue中添加元素,元素个数超过了限制,"+Thread.currentThread().getName()+"被挂起!");
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            // 插入元素并且唤醒take线程
            queue.addLast(data);
            this.notifyAll();
        }
    }

    
    // 从队列中获取元素,如果队列此时为空,则会使当前线程阻塞
    public String take()  {
        synchronized (this) {
            // 判断如果队列为空
            while (queue.isEmpty()) {
                // 则挂起当前线程
                System.out.println(Thread.currentThread().getName()+"从queue中取出元素,元素个数为0,被挂起!");
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    return null;
                }
            }
            //removeFirst不会返回null值,queue没有元素会抛出异常
            String res =  queue.removeFirst();
            // 通知offer线程可以继续插入数据了
            this.notifyAll();
            return  res;
        }
    }

    
    public static void main(String[] args) throws InterruptedException {
        
        GuardedSuspensionQueue queue = new GuardedSuspensionQueue();
        
        TakerThread takerThread = new TakerThread(queue,"【线程A】");
        takerThread.start();
        
        Thread.sleep(2000);
        
        // 创建3个生产线程向queue中添加数据
        IntStream.rangeClosed(1, 3).forEach(i -> {
            new Thread(() -> {
                for (int j = 1; j <= 5; j++) {
                    queue.offer("【线程"+i+"】放入的"+j);
                }
                try {
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        });
        
        Thread.sleep(10_000);
        
        takerThread.close();
    }

}

class TakerThread extends Thread{
    private volatile boolean  close = false;
    private  GuardedSuspensionQueue   queue ;
    TakerThread(GuardedSuspensionQueue queue,String name){
        this.queue = queue;
        setName(name);
    }
    @Override
    public void run() {
        while(!close) {
            String item = queue.take();
            if(item == null) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "从queue中取出数据:" + item);
            try {
                Thread.sleep(GuardedSuspensionQueue.random.nextInt(1000));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                break;
            }
        }
    }
    
    public void close() {
        this.close = close;
        this.interrupt();
    }
    
}

 

 

以上是关于Guarded Suspension设计模式的主要内容,如果未能解决你的问题,请参考以下文章

Guarded Suspension设计模式

并行程序设计模式-Master-Worker模式-Guarded Suspension模式-不变模式-生产者-消费者模式的理解

JAVA多线程模式-Guarded Suspension

实战并发编程 - 08基于Guarded Suspension模式优化轮询while(true)

多线程系列之四:Guarded Suspension 模式

实战并发编程 - 09多线程Guarded Suspension模式案例实战