JAVA多线程设计模式三 Guarded Suspension Pattern

最新推荐文章于 2025-09-07 22:53:01 发布

chenxingzi

最新推荐文章于 2025-09-07 22:53:01 发布

阅读量106

点赞数

CC 4.0 BY-SA版权

文章标签：设计模式 java

本文链接：https://blog.youkuaiyun.com/chenxingzi/article/details/84118128

本文探讨了并发编程中的关键概念，包括等待/通知机制、条件变量的使用及线程间的协作。通过实例展示了如何在请求队列系统中实现线程同步，确保资源的有效管理和避免竞态条件。

一定要满足的条件 Guard Condition ，警戒条件。

public class Request {
    private final String name;
    public Request(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public String toString() {
        return "[ Request " + name + " ]";
    }
}

public class RequestQueue {
    private final LinkedList queue = new LinkedList();
    public synchronized Request getRequest() {
        while (queue.size() <= 0) {
            try {                                   
                wait();
            } catch (InterruptedException e) {      
            }                                       
        }                                           
        return (Request)queue.removeFirst();
    }
    public synchronized void putRequest(Request request) {
        queue.addLast(request);
        notifyAll();
    }
}

public class ClientThread extends Thread {
    private Random random;
    private RequestQueue requestQueue;
    public ClientThread(RequestQueue requestQueue, String name, long seed) {
        super(name);
        this.requestQueue = requestQueue;
        this.random = new Random(seed);
    }
    public void run() {
        for (int i = 0; i < 10000; i++) {
            Request request = new Request("No." + i);
            System.out.println(Thread.currentThread().getName() + " requests " + request);
            requestQueue.putRequest(request);
            try {
                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
            }
        }
    }
}

public class ServerThread extends Thread {
    private Random random;
    private RequestQueue requestQueue;
    public ServerThread(RequestQueue requestQueue, String name, long seed) {
        super(name);
        this.requestQueue = requestQueue;
        this.random = new Random(seed);
    }
    public void run() {
        for (int i = 0; i < 10000; i++) {
            Request request = requestQueue.getRequest();
            System.out.println(Thread.currentThread().getName() + " handles  " + request);
            try {
                Thread.sleep(random.nextInt(1000));
            } catch (InterruptedException e) {
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        RequestQueue requestQueue = new RequestQueue();
        new ClientThread(requestQueue, "Alice", 3141592L).start();
        new ServerThread(requestQueue, "Bobby", 6535897L).start();
    }
}

理解为带条件的同步关键字。 wait / notify

1、while(!ready){
      wait();
}

ready = true;
notifyAll();

2、while(!ready){
     Thread.yield();
}


ready=true;

注：Thread.yield(); 不会解除锁定，所以这句不应该放在同步关键字中。 ready 声明为 volatile