精华内容
下载资源
问答
  • java 线程监控

    2019-06-10 23:41:00
    线程的五种状态 * 新建:new * 运行:runnable * 等待:waitting(无限期等待),timed waitting(限期等待) ...线程的两种监控方法 一,jvisualvm,图形界面的方式 监控之前先对jvm加监控参数,在tomca...

    线程的五种状态

    * 新建:new

    * 运行:runnable

    * 等待:waitting(无限期等待),timed waitting(限期等待)

    * 阻塞:blocked

    * 结束:terminated

                            线程转换关系

     

     

    线程的两种监控方法

    一,jvisualvm,图形界面的方式 监控之前先对jvm加监控参数,在tomcat的bin目录下,catalina.sh文件中,添加: JAVA_OPTS="-Dcom.sun.management.jmxremote.port=10086 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.rmi.server.hostname=192.168.1.108"

    1-改port

    2-改hostname为本机ip

    win系统控制台输入 jvisualvm 启动JAVA Visualvm

     

     

    二,jstack pid(端口号):命令行方式

    三、jstack pid(端口号) >a.log 输出日志

     

    转载于:https://www.cnblogs.com/dwdw/p/11001171.html

    展开全文
  • java线程监控

    2015-07-22 14:06:28
    第一次开始写博客,不知道写些什么,刚好看到java thread线程类,就模拟了一个线程监控小实例 package com.test; public class Test implements Cloneable{ public static void main(String[] args) { ...
    第一次开始写博客,不知道写些什么,刚好看到java thread线程类,就模拟了一个线程监控小实例
    package com.test;

    public class Test implements Cloneable{

    public static void main(String[] args) {
    Test tt = new Test();
    Monitor t = tt.new Monitor(Thread.currentThread());
    Thread pt = new Thread(t);
    pt.start();
    try {
    Thread.sleep(5000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }

    class Monitor implements Runnable{
    private Thread t;
    public Monitor(Thread t){
    this.t = t;
    }

    @Override
    public void run(){
    if(t == null){
    return;
    }
    while(true){
    System.out.println(t.getName() + " 状态:" + t.getState());
    if(!t.isAlive()){
    System.out.println(t.getName() + " is end");
    return;
    }
    }
    }
    }
    }
    展开全文
  • java线程监控程序

    2008-09-06 01:46:43
    有点乐趣,小java线程监控程序, 小java线程监控程序 小java线程监控程序
  • Java线程监控和dump分析性能调测 Java线程详细监控和其dump的分析使用—-分析Java性能瓶颈 https://www.cnblogs.com/firstdream/p/8109352.html 这里对linux下、sun(oracle) JDK的线程资源占用问题的查找步骤做...

    Java线程监控和dump分析性能调测

     

    Java线程详细监控和其dump的分析使用—-分析Java性能瓶颈

    https://www.cnblogs.com/firstdream/p/8109352.html

    这里对linux下、sun(oracle) JDK的线程资源占用问题的查找步骤做一个小结;

    linux环境下,当发现java进程占用CPU资源很高,且又要想更进一步查出哪一个java线程占用了CPU资源时,按照以下步骤进行查找:

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

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

      1. 先用top命令找出占用资源厉害的java进程id,如图:# top
      2. 如上图所示,java的进程id为’52554′,接下来用top命令单独对这个进程中的所有线程作监视:
    1. 1 top  -p 52554 -H

       

      #  top视图里面里面可以通过快捷键依次b ,x高亮显示top的列找出需要的线程,默认CPU排序,Shift+< ,Shift+>可以左右移动高亮排序的列;

      如图:(这时就看出来哪个java线程CPU高,哪个线程内存用的多) 

    2. 如上图所示,linux下,所有的java内部线程,其实都对应了一个进程id,也就是说,linux上的sun jvm将java程序中的线程映射为了操作系统进程;我们看到,占用CPU资源最高的那个进程id是’15417′,这个进程id对应java线程信息中的’nid’(‘n’ stands for ‘native’);
    3. (1)要想找到到底是哪段具体的代码占用了如此多的资源,先使用jstack打出当前栈信息到一个文件里, 比如stack.log:

      1

      jstack 52554 > stack.log

      然后使用’jtgrep’脚本把这个进程号为’9757′的java线程在stack.log中抓出来:

      1 jtgrep 9757 stack.log

      其中,’jtgrep’是自己随便写的一个shell脚本:

      1 #!/bin/sh
      3 nid=`python -c  "print hex($1)" `
      4 grep  -i $nid $2

      道理很简单,就是 把’9757′转换成16进制后,直接grep stack.log;可以看到,被grep出的那个线程的nid=0x3c39,正好是15417的16进制表示。

    (2) 通过(windows程序–>计算器),选择程序员计算器将进程ID转换成16进制 到dump里面的nid 就可以搜索到

    “http-nio-8080-exec-25″ daemon prio=10 tid=0x00007f69686b4800 nid=0x1ce5 waiting on condition [0x00007f698e7cf000]

       java.lang.Thread.State: WAITING (parking)

            at sun.misc.Unsafe.park(Native Method)

            – parking to wait for  <0x0000000777063ec8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

            at java.util.concurrent.locks.LockSupport.park(Unknown Source)

            at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(Unknown Source)

            at java.util.concurrent.LinkedBlockingQueue.take(Unknown Source)

            at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:104)

            at org.apache.tomcat.util.threads.TaskQueue.take(TaskQueue.java:32)

            at java.util.concurrent.ThreadPoolExecutor.getTask(Unknown Source)

            at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)

            at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)

            at java.lang.Thread.run(Unknown Source)

    (二)第二种通过 Java visualMv结合 jconsole.exe   工具即可查看如图所示;(第一种方式可能更准确一些)

     

    三:在Java Visualvm工具里面安装JTA插件,分析线程dump文件,注意,正常阶段的dump文件与非正常时期的Dump文件进行比较更容易分析出问题:

    (1)下载:https://java.net/projects/tda/downloads/directory/visualvm

      (2)安装与使用:

    (3)使用: 

    四:直接通过tda-bin-2.2\bin\tda.sh 来分析导出ThreadDump文件;(在没有JMX监控的情况下手动查看threadDump信息)

           下载地址:https://java.net/projects/tda/downloads/directory/visualvm

     

     

    展开全文
  • Java线程监控及中断

    2018-11-23 21:42:00
    3、另起一个后台线程去执行这个耗时任务(比如生成报表); 4、线程执行成功或失败状态记录到数据库; 5、客户通过异步查询数据(下载报表或其他操作)。 好了,大致步骤我们清楚了。假如这个...

    我们系统中经常有耗费时间长的任务,但客户端往往需要马上得到回应。这时我们就可以如下步骤实现:

    1、客户端发起请求执行任务(选定条件,下载报表);

    2、首先将任务ID及开始时间,起始状态记录到数据库表中;

    3、另起一个后台线程去执行这个耗时任务(比如生成报表);

    4、线程执行成功或失败状态记录到数据库;

    5、客户通过异步查询数据(下载报表或其他操作)。

    好了,大致步骤我们清楚了。假如这个耗时任务一直执行,而且和消耗系统资源。我们往往想放弃这个任务的执行,再缩小范围执行更小的任务执行。那我们如何实现呐!

    话不多说,直接上代码:

    1.首先我们实现一个线程管理工具:

    import java.sql.DriverManager
    import java.util.concurrent.ConcurrentHashMap

    import org.slf4j.LoggerFactory

    import scala.util.{Failure, Success, Try}

    /**
    * 类功能描述:报表线程管理器
    *
    * @author WangXueXing create at 18-11-2 上午11:35
    * @version 1.0.0
    */
    object ReportThreadManager {
    private val logger = LoggerFactory.getLogger(getClass)
    /**
    * 报表ID与对应线程map
    */
    val REPORT_THREAD_MAP: ConcurrentHashMap[Long, Thread] = new ConcurrentHashMap()

    /**
    * 将对应报表子线程放入线程池
    *
    * @param reportId 报表ID
    * @param thread 对应子线程
    */
    def put(reportId: Long, thread: Thread): Unit = {
    REPORT_THREAD_MAP.put(reportId, thread)
    }

    /**
    * 获取对应报表线程
    * @param reportId 报表ID
    * @return
    */
    def get(reportId: Long): Thread ={
    REPORT_THREAD_MAP.get(reportId)
    }

    /**
    * 将对应报表子线程移除线程池
    * @param reportId 报表ID
    */
    def remove(reportId: Long): Unit ={
    REPORT_THREAD_MAP.remove(reportId)
    }

    /**
    * 销毁指定报表子线程
    * @param reportId 报表ID
    */
    def deploy(reportId: Long)={
    val thread = REPORT_THREAD_MAP.get(reportId)
    if(thread != null){
    Try{
    if(!thread.isInterrupted){
    logger.info(s"线程:${reportId} 开始被结束")

    logger.info("before interrupt")
    thread.getStackTrace.foreach(println)

    thread.interrupt()

    Thread.sleep(10)
    logger.info("after interrupt")
    thread.getStackTrace.foreach(println)
    }
    } match {
    case Success(x) => logger.info(s"线程:${reportId} 被成功杀死")
    case Failure(e) => logger.error(s"线程:${reportId} interrupt 失败", e)
    }
    REPORT_THREAD_MAP.remove(reportId)
    }
    }

    val thread1 = new Thread(new Runnable {
    override def run(): Unit = {
    ReportThreadManager.deploy(1)
    println(s"thread 1 killed")
    }
    })

    def main(args: Array[String]): Unit = {
    Class.forName("org.apache.hive.jdbc.HiveDriver")
    val con = DriverManager.getConnection("jdbc:hive2://192.168.71.127:10000/finance", "goods", null)
    val stmt = con.createStatement
    var res = stmt.executeQuery("SELECT company_name,store_code,store_name,source_date,trade_type,trade_no,third_party_payment_no,business_type,cast(business_amount as decimal(20, 2)) business_amount,cast(service_charge as decimal(20, 4)) service_charge,trade_time,customer_account,updated_at,created_at FROM t_pay_source_data")
    while(res.next()){
    println(res.getString(1))
    }
    }
    }
    此工具可以实现根据任务ID添加当前任务执行线程,也可以从线程池移除此线程,根据任务ID中断线程。

    2.如下任务执行过程及如何调用线程管理及中断线程:
    import java.io.{File, FileInputStream}

    import com.today.api.financereport.scala.request.ReportInfo
    import com.today.api.financereport.scala.response.ServiceResponse
    import com.today.service.financereport.action.{ExportReportRecordFailureAction, ExportReportRecordSuccessAction, StartExportReportAction}
    import com.today.service.financereport.common.ReportThreadManager
    import com.today.service.financereport.dto.{ExportReportFailureInput, ExportReportSuccessInput, ReportOutput}
    import com.today.service.financereport.util.{Debug, OssUtil}
    import org.slf4j.LoggerFactory

    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.concurrent.Future
    import scala.util.control.NonFatal
    import scala.util.{Failure, Success}

    /**
    * 报表导出流程限定类
    *
    * @author BarryWang create at 2018/5/17 9:15
    * @version 0.0.1
    */
    trait ReportAction {
    protected val logger = LoggerFactory.getLogger(getClass)
    /**
    * 报表导出流程
    * @return
    */
    def execute: ServiceResponse = {
    var result:ServiceResponse = null
    var count = Counter.count
    logger.info(s"---1生成报表前运行个数:${count}----------")
    if(count >= Counter.MAX_COUNT.intValue()){
    result = ServiceResponse("405", s"目前有多个报表正在导出,请5分钟后再操作,谢谢!")
    } else {
    Counter.increment
    count = Counter.count
    logger.info(s"---2启动生成报表运行个数:${count}----------")
    var reportId: Long = -1
    try {
    //1. 前置检查
    preCheck

    //2. 开始生成报表纪录
    val reportInfo = setReportInfo
    reportId = startGenerate

    //3. 生成报表处理
    val output: Future[ReportOutput] = Future {
    Debug.reset()
    //添加当前子线程到线程管理池
    ReportThreadManager.put(reportId, Thread.currentThread())
    //1) 加载模板
    val templateInfo = Debug.trace(s"${reportInfo.reportType}-loadTemplate:")(loadTemplate(setTemplatePath))
    //2) 生成报表
    Debug.trace(s"${reportInfo.reportType}-generateReport:")(generateReport(reportId, templateInfo))
    //3) 保存报表
    val output = Debug.trace(s"${reportInfo.reportType}-saveReport:")(saveReport(templateInfo.localFile))

    //将此子线程从线程管理池移除
    ReportThreadManager.remove(reportId)

    Debug.info()
    output
    }
    output.onComplete {
    case Success(v) => {
    successGenerate(ExportReportSuccessInput(reportId, v))
    Counter.decrement
    count = Counter.count
    logger.info(s"---3结束报表生成运行个数:${count}----------")
    }
    case Failure(e) => {
    failureGenerate(ExportReportFailureInput(reportId, e))
    Counter.decrement
    count = Counter.count
    logger.info(s"---3结束报表生成运行个数:${count}----------")
    }
    }

    //4. 后置检查
    postCheck

    result = ServiceResponse("200", "请到导出管理查看或下载报表")
    } catch {
    case NonFatal(e) =>
    Counter.decrement
    count = Counter.count
    logger.info(s"---3结束报表生成运行个数:${count}----------")
    failureGenerate(ExportReportFailureInput(reportId, e))
    throw e
    } finally {}
    }
    result
    }

    /**
    * 前置条件检查:动作、状态等业务逻辑
    */
    def preCheck

    /**
    * 设置报表信息
    * @return
    */
    def setReportInfo: ReportInfo

    /**
    * 设置模板路径
    * @return
    */
    def setTemplatePath: String

    /**
    * 开始生成报表纪录
    */
    def startGenerate(): Long = {
    new StartExportReportAction(setReportInfo).execute
    }

    /**
    * 加载模板
    * @param templatPath
    */
    def loadTemplate(templatPath: String): ExcelTemaplateInfo = {
    val suffix = isZip match {
    case true => ".zip"
    case false => ".xlsx"
    }
    //生成本地文件
    val localFile = File.createTempFile(downloadFileName+"_", suffix)
    ExcelTemaplateInfo(templatPath, localFile)
    }

    /**
    * 下载文件名
    * @return
    */
    def downloadFileName: String = setReportInfo.reportType.name

    /**
    * 根据数据生成报表
    * @return
    */
    def generateReport(reportId: Long, templateInfo: ExcelTemaplateInfo)

    /**
    * 将生成在本地的报表上传到阿里SSO
    * @param localFile
    * @return
    */
    def saveReport(localFile: File): ReportOutput = {
    val fileUrl = OssUtil.uploadFileStream(new FileInputStream(localFile), localFile.getName)
    localFile.deleteOnExit()
    val suffix = isZip match {
    case true => ".zip"
    case false => ".xlsx"
    }
    // OssUtil.downloadFile(fileUrl, "/home/barry/data/1122322"+suffix)
    ReportOutput(fileUrl)
    }

    /**
    * 最终生成报表是否为Zip
    * @return
    */
    def isZip: Boolean

    /**
    * 成功生成报表纪录
    * @param result: ExportReportSuccessInput
    */
    def successGenerate(result: ExportReportSuccessInput): Unit = {
    new ExportReportRecordSuccessAction(result).execute
    }

    /**
    * 失败生成报表纪录
    * @param result: ExportReportFailureInput
    */
    def failureGenerate(result: ExportReportFailureInput): Unit = {
    new ExportReportRecordFailureAction(result).execute
    }

    /**
    * 后置检查
    */
    def postCheck = {}
    }

    3.客户端触发中断当前任务线程:
    import com.today.api.financereport.scala.response.ServiceResponse
    import com.today.service.commons.Action
    import com.today.service.financereport.action.sql.ExportReportRecordActionSql
    import com.today.service.financereport.common.ReportThreadManager

    /**
    * 类功能描述:报表删除Action
    *
    * @author WangXueXing create at 18-11-2 下午2:17
    * @version 1.0.0
    */
    class DeleteExportReportAction(id: Long) extends Action[ServiceResponse]{
    override def preCheck: Unit = {}

    override def action: ServiceResponse = {
    val result = ExportReportRecordActionSql.deleteExportReportById(id)
    result match {
    case 0 => ServiceResponse("501","删除报表失败")
    case _ => {
    //删除报表的同时结束生成报表线程
    new Thread(new Runnable {
    /**
    * 延迟退出系统
    */
    override def run(): Unit = {
    Thread.sleep(50)
    ReportThreadManager.deploy(id)
    }
    }).start()
    ServiceResponse("200","success")
    }
    }
    }
    }

    转载于:https://www.cnblogs.com/barrywxx/p/10009884.html

    展开全文
  • jvisualvm 使用手册 一 VisualVM 简 介 VisualVM 能 够 监 控 线程 内 存情况 查 看 方 法的 CPU 时 间 和 内 存中 的 对 象 已 被 GC 的 对 象 反 向查 看 分 配 的 堆 栈 ( 如 100 个 String 对 象 分 别 由哪 几 ...
  • 线程的五种状态* 新建:new* 运行:runnable* 等待:waitting(无...线程的两种监控方法一,jvisualvm,图形界面的方式监控之前先对jvm加监控参数,在tomcat的bin目录下,catalina.sh文件中,第二行添加:JAVA_OPTS...
  • 我们尝试过很多方法来进行Java线程状态的监控,比如开始时使用jstat、jps等工具来读取JVM的状态,同时也尝试用过Zabbix的Java proxy,但都不能满足电商ERP产品性能监控需求。后来通过脚本来调用这些工具读取状态后,...
  • java线程监控数据库中某一张表是否有新纪录产生,有就将新记录查询出来。
  • Java线程超时监控

    2014-07-18 09:01:18
    讲解有关Java中多线程运行时针对单个线程的执行超时监控机制,用于处理单个线程执行控制
  • java 监控线程

    2014-06-27 16:34:49
    java 监控 线程
  • AOP在JAVA线程监控中的应用AOP在JAVA线程监控中的应用AOP在JAVA线程监控中的应用AOP在JAVA线程监控中的应用AOP在JAVA线程监控中的应用
  • Java 多线程之线程监控

    千次阅读 2016-07-22 12:09:14
    在这里我们使用一个监控线程的概念。我们可以定义一个线程继承自Thread类,在其中定义一个Map集合,用于存放我们需要管理的线程;当我们需要对某个线程进行操作时,我们就可以根据他的key值获取到;
  • 监控java线程

    2017-10-19 15:15:15
    我们大致能分析出线程应该占有多少cpu资源,但是,程序可能并没有按我们预想的去运行,这样,我们有时候需要能够有效的监控它。好在jdk的devel包已经带了很多的监控工具来完成这个任务。
  • 主要介绍了java 使用线程监控文件目录变化的实现方法的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下
  • ``` ps -T -p [pid] ``` Java线程监控分析(一般流程) 1.先用top命令找出占用资源比较多的java进程id 我们以第一个进程为例,对该进程的所有线程进行监控 2.查看相关进程的所有线程 接下来我们以第一个线程为例,对...
  • Java 虚拟机线程监控

    2013-07-14 22:27:20
    java"] /** * Created with IntelliJ IDEA. * User: zy * To change this template use File | Settings | File Templates. */ @Controller public class ConsoleFrontManager extends BaseContro.....
  • 基于 JVMTI 实现 Java 线程监控

    千次阅读 2015-06-30 03:09:41
    Java 语言对多线程编程提供了语言级的支持,可以方便地创建、运行、销毁线程。然而,多线程的使用也给应用程序开发人员带来了巨大的挑战,不正确地使用多线程可能造成线程死锁或资源竞争,导致系统瘫痪。 为了...
  • 撇开代码检查工具,我们先讨论一下利用VisualVM监控,分析我们的多线程的运行情况。 AD:51CTO学院:IT精品课程在线看! 在Java线程程序运行时,多数情况下我们不知道到底发生了什么,只有出了错误的日志...
  • // java使用一个线程监控另一个线程 // 这里写的是例子,实际应用是一个线程监控主线程某个属性的值 // 当值发生改变时,做出相应的业务逻辑 public class B extends Thread { static int num = 1; public static ...
  • Java线程及Jvm监控工具

    2016-05-21 19:25:00
    Java线程状态 线程的五种状态 * 新建:new(时间很短) * 运行:runnable * 等待:waitting(无限期等待),timed waitting(限期等待) * 阻塞:blocked * 结束:terminated(时间很短) Jvm监控工具 一、...
  • 随着多核 CPU 的日益普及,越来越多的 Java 应用程序使用多线程并行计算来充分...因此,需要一种运行时线程监控工具来帮助开发人员诊断和跟踪 Java 线程状态的切换。JDK 1.5 及其后续版本提供了监控虚拟机运行状态的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,733
精华内容 1,493
关键字:

java线程监控

java 订阅