「java线程监控」jvm监控线程

本篇文章给大家谈谈java线程监控，以及jvm监控线程对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java 怎么监控linux上线程是否存在
• 2、java executors有哪些方法
• 3、java 如何获得线程池中正在执行的线程数
• 4、java如何监控线程是否在运行
• 5、java多线程开发的同步机制有哪些

java 怎么监控linux上线程是否存在

CPU资源时，按照以下步骤进行查找：

(一)：通过【 top -p 12377 -H】 查看java进程的有哪些线程的运行情况；

和通过【jstack 12377 stack.log】生成Java线程的dump详细信息；

先用top命令找出占用资源厉害的java进程id，如图：# top

如上图所示，java的进程id为’52554′，接下来用top命令单独对这个进程中的所有线程作监视：

1 top -p 52554 -H

# top视图里面里面可以通过快捷键依次b ,x高亮显示top的列找出需要的线程，默认CPU排序，Sh

java executors有哪些方法

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1) newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

Java代码

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

for (int i = 0; i  10; i++) {

final int index = i;

try {

Thread.sleep(index * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

cachedThreadPool.execute(new Runnable() {

public void run() {

System.out.println(index);

}

});

}

}

}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

(2) newFixedThreadPool（项目用过）

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

Java代码

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

for (int i = 0; i  10; i++) {

final int index = i;

fixedThreadPool.execute(new Runnable() {

public void run() {

try {

System.out.println(index);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

}

}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

Java代码

package test;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

scheduledThreadPool.schedule(new Runnable() {

public void run() {

System.out.println("delay 3 seconds");

}

}, 3, TimeUnit.SECONDS);

}

}

表示延迟3秒执行。

定期执行示例代码如下：

Java代码

package test;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

public void run() {

System.out.println("delay 1 seconds, and excute every 3 seconds");

}

}, 1, 3, TimeUnit.SECONDS);

}

}

表示延迟1秒后每3秒执行一次。

(4) newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

Java代码

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

for (int i = 0; i  10; i++) {

final int index = i;

singleThreadExecutor.execute(new Runnable() {

public void run() {

try {

System.out.println(index);

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

}

}

}

结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：

工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe

运行程序做稍微修改：

Java代码

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();

for (int i = 0; i  100; i++) {

final int index = i;

singleThreadExecutor.execute(new Runnable() {

public void run() {

try {

while(true) {

System.out.println(index);

Thread.sleep(10 * 1000);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

java 如何获得线程池中正在执行的线程数

java中线程池的监控可以检测到正在执行的线程数。

通过线程池提供的参数进行监控。线程池里有一些属性在监控线程池的时候可以使用

taskCount：线程池需要执行的任务数量。

completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。

largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。

getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不+ getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，我们可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：

protected void beforeExecute(Thread t, Runnable r) { }

java如何监控线程是否在运行

判断是否在运行用isAlive方法哈。。

给你写了个例子。。不知是不是你想要的。。

public class Thread100 {

/**

* @param args

*/

public static ThreadA ta = new ThreadA();

public static ThreadB tb = new ThreadB();

public static void main(String[] args) {

ta.start();

tb.start();

}

}

class ThreadA extends Thread {

@Override

public void run() {

int i = 0;

while(i 100) {

if(Thread100.tb.isAlive()) {

System.out.println("B is alive");

}

System.out.println(i);

i++;

}

}

}

class ThreadB extends Thread {

@Override

public void run() {

int i = 0;

while(i 100) {

if(Thread100.ta.isAlive()) {

System.out.println("A is alive");

}

System.out.println(i);

i++;

}

}

}

java多线程开发的同步机制有哪些

Java同步

标签： 分类：

一、关键字：

thread（线程）、thread-safe(线程安全)、intercurrent（并发的）

synchronized(同步的)、asynchronized(异步的)、

volatile（易变的）、atomic（原子的）、share（共享）

二、总结背景：

一次读写共享文件编写，嚯，好家伙，竟然揪出这些零碎而又是一路的知识点。于是乎，Google和翻阅了《Java参考大全》、《Effective Java Second Edition》，特此总结一下供日后工作学习参考。

三、概念：

1、 什么时候必须同步？什么叫同步？如何同步？

要跨线程维护正确的可见性，只要在几个线程之间共享非 final 变量，就必须使用 synchronized（或 volatile）以确保一个线程可以看见另一个线程做的更改。

为了在线程之间进行可靠的通信，也为了互斥访问，同步是必须的。这归因于java语言规范的内存模型，它规定了：一个线程所做的变化何时以及如何变成对其它线程可见。

因为多线程将异步行为引进程序，所以在需要同步时，必须有一种方法强制进行。例如：如果2个线程想要通信并且要共享一个复杂的数据结构，如链表，此时需要

确保它们互不冲突，也就是必须阻止B线程在A线程读数据的过程中向链表里面写数据（A获得了锁，B必须等A释放了该锁）。

为了达到这个目的，java在一个旧的的进程同步模型——监控器（Monitor）的基础上实现了一个巧妙的方案：监控器是一个控制机制，可以认为是一个

很小的、只能容纳一个线程的盒子，一旦一个线程进入监控器，其它的线程必须等待，直到那个线程退出监控为止。通过这种方式，一个监控器可以保证共享资源在

同一时刻只可被一个线程使用。这种方式称之为同步。（一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例

的非同步方法仍然能够被调用）。

错误的理解：同步嘛，就是几个线程可以同时进行访问。

同步和多线程关系：没多线程环境就不需要同步;有多线程环境也不一定需要同步。

锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。

互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。

可见性要更加复杂一些，documents它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题

小结：为了防止多个线程并发对同一数据的修改，所以需要同步，否则会造成数据不一致（就是所谓的：线程安全。如java集合框架中Hashtable和

Vector是线程安全的。我们的大部分程序都不是线程安全的，因为没有进行同步，而且我们没有必要，因为大部分情况根本没有多线程环境）。

2、 什么叫原子的（原子操作）？

Java原子操作是指：不会被打断地的操作。（就是做到互斥 和可见性？！）

那难道原子操作就可以真的达到线程安全同步效果了吗？实际上有一些原子操作不一定是线程安全的。

那么，原子操作在什么情况下不是线程安全的呢？也许是这个原因导致的：java线程允许线程在自己的内存区保存变量的副本。允许线程使用本地的私有拷贝进

行工作而非每次都使用主存的值是为了提高性能（本人愚见：虽然原子操作是线程安全的，可各线程在得到变量（读操作）后，就是各自玩

弄自己的副本了，更新操作（写操作）因未写入主存中，导致其它线程不可见）。

那该如何解决呢？因此需要通过java同步机制。

在java中，32位或者更少位数的赋值是原子的。在一个32位的硬件平台上，除了double和long型的其它原始类型通常都

是使用32位进行表示，而double和long通常使用64位表示。另外，对象引用使用本机指针实现，通常也是32位的。对这些32位的类型的操作是原

子的。

这些原始类型通常使用32位或者64位表示，这又引入了另一个小小的神话：原始类型的大小是由语言保证的。这是不对的。java语言保证的是原始类型的表

数范围而非JVM中的存储大小。因此，int型总是有相同的表数范围。在一个JVM上可能使用32位实现，而在另一个JVM上可能是64位的。在此再次强

调：在所有平台上被保证的是表数范围，32位以及更小的值的操作是原子的。

3、 不要搞混了：同步、异步

举个例子：普通B/S模式（同步）AJAX技术（异步）

同步：提交请求-等待服务器处理-处理完返回 这个期间客户端浏览器不能干任何事

异步：请求通过事件触发-服务器处理（这是浏览器仍然可以作其他事情）-处理完毕

可见，彼“同步”非此“同步”——我们说的java中的那个共享数据同步（synchronized）

一个同步的对象是指行为（动作），一个是同步的对象是指物质（共享数据）。

4、 Java同步机制有4种实现方式：（部分引用网上资源）

① ThreadLocal ② synchronized( ) ③ wait() 与 notify() ④ volatile

目的：都是为了解决多线程中的对同一变量的访问冲突

ThreadLocal

ThreadLocal 保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程的副本冲突。

优势：提供了线程安全的共享对象

与其它同步机制的区别：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信；而 ThreadLocal 是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源，这样当然不需要多个线程进行同步了。

volatile

volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。

优势：这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

缘由：Java

语言规范中指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原

始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而 volatile

关键字就是提示 VM ：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用技巧：在两个或者更多的线程访问的成员变量上使用 volatile 。当要访问的变量已在 synchronized 代码块中，或者为常量时，不必使用。

线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步，因此存在A和B不一致

的情况。volatile就是用来避免这种情况的。

volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（读操作多时使用较好；线程间需要通信，本条做不到）

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile

变量的最新值。Volatile

变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值

之间没有约束。

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。

sleep() vs wait()

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

（如果变量被声明为volatile，在每次访问时都会和主存一致；如果变量在同步方法或者同步块中被访问，当在方法或者块的入口处获得锁以及方法或者块退出时释放锁时变量被同步。）

关于java线程监控和jvm监控线程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。