如何检查有多少线程正在等待同步方法解锁

发布于 2024-08-25 05:14:11 字数 968 浏览 2 评论 0原文

有什么方法可以检查有多少线程正在等待同步方法解锁？

我想知道线程何时调用同步方法：

1）有多少线程已经在等待调用该方法？

2）一旦调用该方法，需要等待该方法解锁多长时间？

解决方案：我使用堆垛机答案解决了这个问题：

public class LockedClass {
    public static int count;
    public static void measuringClass() throws IOException{
        long startTime = System.currentTimeMillis();
        count++;
        System.out.println("Threads waiting="+count);
        lockedMethod(startTime);
        count--;
        System.out.println("Threads waiting="+count);
    }
    public static synchronized void lockedMethod(long startTime) throws IOException{
        System.out.println("I spent="+(System.currentTimeMillis()-startTime)+" in the queue");
        Hashtable<String, String> params = new Hashtable<String, String>();
        params.put("param1", "test");
        params.put("param2", "12345678");
        String sessionId = Common.getSession(Common.executeHttpRequest(params));
    }
}

原文

Is there any way to check how many threads are waiting for a synchronized method to become unlocked?

I would like to know when the thread calls a synchronized method:

1) How many threads are already waiting to call the method?

2) Once the method is called how long it needed to wait for the method to become unlocked?

Solution:
I solved this using stackers answer:

public class LockedClass {
    public static int count;
    public static void measuringClass() throws IOException{
        long startTime = System.currentTimeMillis();
        count++;
        System.out.println("Threads waiting="+count);
        lockedMethod(startTime);
        count--;
        System.out.println("Threads waiting="+count);
    }
    public static synchronized void lockedMethod(long startTime) throws IOException{
        System.out.println("I spent="+(System.currentTimeMillis()-startTime)+" in the queue");
        Hashtable<String, String> params = new Hashtable<String, String>();
        params.put("param1", "test");
        params.put("param2", "12345678");
        String sessionId = Common.getSession(Common.executeHttpRequest(params));
    }
}

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

蓝戈者 2024-09-01 05:14:11

1）我认为您的代码不可能达到这种级别的可见性。 Java提供了更加强大的并发 API 提供更直接的控制和可见性。作为起点，有一个 Semaphore 类，它有一个方法 getQueueLength() 这听起来可能就是你想要的。

2）当调用同步方法时，调用线程将等待直到该方法被解锁，需要多长时间取决于带有锁的代码执行其操作所需的时间。当对对象进行 wait() 时，您可以指定超时。我不相信你可以用同步方法做到这一点。

回复收藏 0 原文

旧情别恋 2024-09-01 05:14:11

您可以将代码转换为使用同步块而不是同步方法，这是我的草稿。我不确定它是否符合您的第二个要求（由于我的英语不稳定）

public class Sync {
    public static int waiting = 0;
    private Object mutex = new Object();

    public void sync() {
        waiting++;
        synchronized (mutex) {
            waiting--;
            long start = System.currentTimeMillis();
            doWhatever();
            System.out.println("duration:"
                    + (System.currentTimeMillis() - start));
        }
    }
}

You could transform your code to use a synchronized block instead of synchronized methods, here is my rough draft. I'm not sure whether it matches you second requirement (due to my choppy english)

public class Sync {
    public static int waiting = 0;
    private Object mutex = new Object();

    public void sync() {
        waiting++;
        synchronized (mutex) {
            waiting--;
            long start = System.currentTimeMillis();
            doWhatever();
            System.out.println("duration:"
                    + (System.currentTimeMillis() - start));
        }
    }
}

回复收藏 0 原文