获取java中活动线程的数量

我有一个类（extends

Thread

），其中我正在运行多个线程

下面是课堂：

public class Abc extends Thread{
    private String key;
    public void run(){}
}

现在，我想根据

key

的值知道这个类有多少活动线程

我在10个线程中将key的值设置为“X”，在15个线程中将key的值设置为“Y”。我想创建一张地图：

map<String, int> :: {"X"=10, "Y"=15}

map:：{“X”=10，“Y”=15}

我该怎么做

编辑：

---

这个

Map

将存储在创建线程的

Execute

类中。它与

Abc

无关。您可以在任务开始时增加计数器，在任务完成时减少计数器

差不多

public void run() {
     AtomicInteger counter = counterMap.computeIfAbsent(key, k -> new AtomicInteger());
     counter.incrementAndGet();
     try {
         doRun();
     } finally {
         counter.getAndDecrement();
     }
 }

---

您可以在任务开始时递增计数器，在任务完成时递减计数器

差不多

public void run() {
     AtomicInteger counter = counterMap.computeIfAbsent(key, k -> new AtomicInteger());
     counter.incrementAndGet();
     try {
         doRun();
     } finally {
         counter.getAndDecrement();
     }
 }

---

使您的

键

为静态，这样它将在线程之间保持其值。

使您的

键

为静态，这样它将在线程之间保持其值。

您可以执行以下操作：

static HashMap<String, Integer> threadsCount = new HashMap<String, Integer>();
String key;

public Abc(String key) {
    this.key = key;
    synchronized (threadsCount) {
        if (threadsCount.containsKey(key)) {
            threadsCount.put(key, threadsCount.get(key) + 1);
        } else {
            threadsCount.put(key, 1);
        }
    }
}

@vish4071，根据您的意见，我认为更好的解决方案是：

public class Abc extends Thread {
    String key;

    public Abc(String key) {
        this.key = key;
    }

    public String getKey(){
        return key;
    }
    ....
}

要获得计数：

HashMap<String, Integer> threadsCount = new HashMap<String, Integer>();

for (Thread t : Thread.getAllStackTraces().keySet()) {
    if (t instanceof Abc) {
        if (t.getState() != Thread.State.TERMINATED) {
            String key = ((Abc)t).getKey();
            if (threadsCount.containsKey(key)) {
                threadsCount.put(key, threadsCount.get(key) + 1);
            } else {
                threadsCount.put(key, 1);
            }
        }
    }
}

HashMap threadscont=newhashmap（）；
对于（线程t:Thread.getAllStackTraces（）.keySet（））{
如果（Abc的t实例）{
if（t.getState（）！=Thread.State.TERMINATED）{
字符串键=（（Abc）t）.getKey（）；
if（螺纹槽容器（图例））{
threadscont.put（key，threadscont.get（key）+1）；
}否则{
螺纹接头（图例1）；
}
}
}
}

您可以执行以下操作：

static HashMap<String, Integer> threadsCount = new HashMap<String, Integer>();
String key;

public Abc(String key) {
    this.key = key;
    synchronized (threadsCount) {
        if (threadsCount.containsKey(key)) {
            threadsCount.put(key, threadsCount.get(key) + 1);
        } else {
            threadsCount.put(key, 1);
        }
    }
}

@vish4071，根据您的意见，我认为更好的解决方案是：

public class Abc extends Thread {
    String key;

    public Abc(String key) {
        this.key = key;
    }

    public String getKey(){
        return key;
    }
    ....
}

要获得计数：

HashMap<String, Integer> threadsCount = new HashMap<String, Integer>();

for (Thread t : Thread.getAllStackTraces().keySet()) {
    if (t instanceof Abc) {
        if (t.getState() != Thread.State.TERMINATED) {
            String key = ((Abc)t).getKey();
            if (threadsCount.containsKey(key)) {
                threadsCount.put(key, threadsCount.get(key) + 1);
            } else {
                threadsCount.put(key, 1);
            }
        }
    }
}

HashMap threadscont=newhashmap（）；
对于（线程t:Thread.getAllStackTraces（）.keySet（））{
如果（Abc的t实例）{
if（t.getState（）！=Thread.State.TERMINATED）{
字符串键=（（Abc）t）.getKey（）；
if（螺纹槽容器（图例））{
threadscont.put（key，threadscont.get（key）+1）；
}否则{
螺纹接头（图例1）；
}
}
}
}

公共类Abc扩展线程{
私有静态映射=新的ConcurrentHashMap（）；
私钥；
公开募捐{
已同步（键）{
当前整数=map.get（键）；
如果（空==当前）{
地图放置（图例1）；
}否则{
映射放置（键，当前+1）；
}
}
//在这里运行执行代码。
已同步（键）{
当前整数=map.get（键）；
map.put（键，当前-1）；
}
}
}

公共类Abc扩展线程{
私有静态映射=新的ConcurrentHashMap（）；
私钥；
公开募捐{
已同步（键）{
当前整数=map.get（键）；
如果（空==当前）{
地图放置（图例1）；
}否则{
映射放置（键，当前+1）；
}
}
//在这里运行执行代码。
已同步（键）{
当前整数=map.get（键）；
map.put（键，当前-1）；
}
}
}

我看到了。它没有告诉你如何根据某个值进行分类。你的问题不太清楚。您的

键应具有哪些值？地图是你线程的一部分吗？根据mapI将编辑的问题，编写一个示例代码，说明如何更改
键
@阿德拉纳尔，完成了，我看到了。它没有告诉你如何根据某个值进行分类。你的问题不太清楚。您的
键应具有哪些值？地图是你线程的一部分吗？根据mapI将编辑的问题，编写一个示例代码，说明如何更改
键
@A分析，完成。
键有多个值。它不能是静态的。
键
有多个值。它不能是静态的。为什么我要使用
synchronized
？@vish4071来确保
threadscont.containsKey（key）
返回
true
，即使您同时使用同一
键创建多个线程。这是一个很好的答案，但不适合我的用例。如果由于某种原因（系统级），某个线程停止运行（崩溃），该怎么办？因为线程在一个完全不同的进程上工作。另外，我必须自己关闭线程，那些正在运行的线程将永远运行。我为什么要使用
synchronized
？@vish4071来确保
threadscont.containsKey（键）
返回
true
，即使您同时使用相同的
键创建多个线程也是如此。这是一个很好的答案，但不适合我的用例。如果由于某种原因（系统级），某个线程停止运行（崩溃），该怎么办？因为线程在一个完全不同的进程上工作。而且，我必须自己关闭线程，那些正在运行的线程将永远运行。