「java线程泄漏」线程池泄露

今天给各位分享java线程泄漏的知识，其中也会对线程池泄露进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java销毁线程池
• 2、java 线程问题
• 3、请问什么叫java内存泄露?
• 4、java既然存在gc线程，为什么还存在内存泄漏
• 5、如何排查Java内存泄露
• 6、java多线程,对象锁是什么概念?

java销毁线程池

你是用Java自带的ExecutorService这个线程池么？如果是的话，ExecutorService自身会管理池中的线程，不需外界手动干预。

如果是自己写的话，必须在线程池内的线程加入退出判定，要不然的话是没法从线程外结束线程的。（你也不应该这样做，因为这样会导致验证的资源泄漏）

java 线程问题

java中对线程描述的类是java.lang.Thread。

创建线程有两种方式：

1.定义一个类继承Thread。

  这个类需要复写父类的run方法，线程启动时会自动调用run方法。

  创建Thread或其子类对象等于创建了一个线程，调用start()方法启动这个线程，启动线程后会自动调用run方法。

Thread t = new Thread();//创建一个线程。

t.start();//线程开始运行，调用run方法。

//Thread中的run方法没有任何意义，所以需要复写,自定义线程该做的事情。

2.定义一个类实现Runnable，复写run方法，将对象以参数的形式传入Thread的构造函数，调用start方法运行线程。

public class MyThread implements Runnable //定义线程类

{

    public void run(){}

    static

    {

        MyThread mt = new MyThread();//创建对象

        Thread t = new Thread(mt);//使用构造方法的方式将线程对象传入

        t.start();//开启线程并运行run方法

    }

}

线程经常会出现安全隐患问题，java 1.5版本之前一般使用同步（synchronized）来解决，在1.5之后java对同步进行了封装，java.util.concurrent.locks.lock，使得同步的使用更加灵活。

线程是拥有优先级的（1-10），优先级高的线程一般来说执行的次数会更多，不过差距并不大，可以调用setPriority(int newPriority)方法自定义线程的优先级。

一个自定义线程可以将其设置为守护线程或用户线程，或者说是后台线程，即在其他线程结束后，这个线程会直接结束，调用setDaemon(boolean on)方法设置。

线程在运行时拥有多个状态：

NEW（未调用start方法）

至今尚未启动的线程处于这种状态。

RUNNABLE（执行）

正在

Java 虚拟机中执行的线程处于这种状态。

BLOCKED（等待）

受阻塞并等待某个监视器锁的线程处于这种状态。

WAITING（冻结）

无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。

TIMED_WAITING（睡眠）

等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

TERMINATED（结束）

已退出的线程处于这种状态。

在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

请问什么叫java内存泄露?

上面的已经介绍得很清楚了，简单点说就是java没有释放用过的内存，继续在系统内存中占用！

java既然存在gc线程，为什么还存在内存泄漏

无论哪种语言的内存分配方式，都需要返回分配内存的真实地址，Java中对象通过new关键字或反射创建对象，存放在堆中，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的，GC会检测长时间没有使用的对象进行回收，但是像一些静态字段、静态引用类、数据库的连接、网络连接等，若没有正确处理，还是会造成内存泄漏。

如何排查Java内存泄露

1.打开/tomcat_home/bin/catalina.bat文件

2.加上：set JAVA_OPTS=%JAVA_OPTS% -server -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\heapdump，这样当内存溢出是就会在对应路径下生成dump文件

运行程序打开jdk bin 文件夹下再带的 jvisualvm.exe

选择tomcat线程，打开实时监控页面可以看到对应的堆栈线程和装在类，内存的实时情况

运行程序打开jdk bin 文件夹下再带的 jconsole.exe，可以概览堆栈线程和装在类，内存的全部运行时间情况

下载安装mat，dump分析软件，安装后，点击file open 导入dump文件

打开后，灰色区域为可能发生内存溢出的区域，下带问题描述

选择Histogram，点击shallow列进行排序，找出实例最多的

右键实例最的选择list objects-with incoming references，可在根据正则表达式输入自己想查的类，搜索，后右键打开 path to gc root-exclude phantom/weak/soft etc. references 就可以查出 调用为回收的相关信息。

java多线程,对象锁是什么概念?

java线程:

1．线程中一些基本术语和概念

1.1线程的几个状态

初始化状态

就绪状态

运行状态

阻塞状态

终止状态

1.2 Daemon线程

Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。

1.3锁的定义

为了协调多个并发运行的线程使用共享资源才引入了锁的概念。

1.4死锁

任何多线程应用程序都有死锁风险。当一组线程中的每一个都在等待一个只

有该组中另一个线程才能引起的事件时，我们就说这组线程死锁了。换一个说法

就是一组线程中的每一个成员都在等待别的成员占有的资源时候，就可以说这组

线程进入了死锁。死锁的最简单情形是：线程 A 持有对象 X 的独占锁，并且

在等待对象 Y 的锁，而线程 B 持有对象 Y 的独占锁，却在等待对象 X 的锁。

除非有某种方法来打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线

程将永远等下去。

1.5.Java对象关于锁的几个方法

1.5.1 wait方法

wait方法是java根对象Object含有的方法，表示等待获取某个锁。在wait方法进入前，会释放相应的锁，在wait方法返回时，会再次获得某个锁。

如果wait()方法不带有参数，那只有当持有该对象锁的其他线程调用了notify或者notifyAll方法，才有可能再次获得该对象的锁。

如果wait()方法带有参数，比如：wait(10)，那当持有该对象锁的其他线程调用了notify或者notifyAll方法，或者指定时间已经过去了，才有可能再次获得该对象的锁。

参考 thread.lock.SleepAndWait

1.5.2 notify/notifyAll方法

这里我就不再说明了。哈哈，偷点懒。

1.5.3 yield方法

yield()会自动放弃CPU，有时比sleep更能提升性能。

1.6锁对象(实例方法的锁)

在同步代码块中使用锁的时候，担当锁的对象可以是这个代码所在对象本身或者一个单独的对象担任，但是一定要确保锁对象不能为空。如果对一个null对象加锁，会产生异常的。原则上不要选择一个可能在锁的作用域中会改变值的实例变量作为锁对象。

锁对象,一种是对象自己担任，一种是定义一个普通的对象作为private property来担任，另外一种是建立一个新的类，然后用该类的实例来担任。

参考 :

thread.lock.UseSelfAsLock，使用对象自己做锁对象

thread.lock.UseObjAsLock 使用一个实例对象作锁对象

thread.lock.UseAFinalObjAsLock使用常量对象作为一个锁对象

1.7类锁

实例方法存在同步的问题，同样，类方法也存在需要同步的情形。一般类方法的类锁是一个static object来担任的。当然也可以采用类本身的类对象来作为类锁。

一个类的实例方法可以获得该类实例锁，还可以尝试去访问类方法，包含类同步方法，去获得类锁。

一个类的类方法，可以尝试获得类锁，但是不可以尝试直接获得实例锁。需要先生成一个实例，然后在申请获得这个实例的实例锁。

参考

thread.lock.UseStaticObjAsStaticLock 使用类的属性对象作为类锁。

thread.lock.UseClassAsStaticLock使用类的类对象作为类锁

1.8.线程安全方法与线程不安全方法

如果一个对象的所有的public方法都是同步方法，也就是说是public方法是线程安全的，那该对象的private方法，在不考虑继承的情况下，可以设置为不是线程安全的方法。

参考 thread.lock.SynMethrodAndNotSynMethrod

1.9类锁和实例锁混合使用

在实例方法中混合使用类锁和实例锁；可以根据前面说的那样使用实例锁和类锁。

在类方法中混合使用类锁和实例锁，可以根据前面说的那样使用类锁，为了使用实例锁，先得生成一个实例，然后实例锁。

参考 thread.lock.StaticLockAndObjLock

1.10锁的粒度问题。

为了解决对象锁的粒度过粗，会导死锁出现的可能性加大，锁的粒度过细，会程序开发维护的工作加大。对于锁的粒度大小，这完全要根据实际开发需要来考虑，很难有一个统一的标准。

1.11.读写锁

一个读写锁支持多个线程同时访问一个对象，但是在同一时刻只有一个线程可以修改此对象，并且在访问进行时不能修改。

有2种调度策略，一种是读锁优先，另外就是写锁优先。

参考 thread.lock.ReadWriteLock

1.12 volatile

在Java中设置变量值的操作，除了long和double类型的变量外都是原子操作，也就是说，对于变量值的简单读写操作没有必要进行同步。这在JVM 1.2之前，Java的内存模型实现总是从主存读取变量，是不需要进行特别的注意的。而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。

2．线程之间的通讯

在其他语言中，线程之间可以通过消息队列，共享内存，管道等方式来实现

线程之间的通讯，但是java中可以不采用这样方式，关注的是线程之间的同步。

只要保证相关方法运行的线程安全，信息共享是自然就可以显现了。

2.1屏障

屏障就是这样的一个等待点: 一组线程在这一点被同步，这些线程合并各自的结果或者运行到整体任务的下一阶段。

参考：

thread.lock. BarrierUseExample

thread.lock.Barrier

2.2.锁工具类

提供对线程锁的获取，释放功能。展示了锁的获取释放过程。可以作为一个工具类来使用。

参考：thread.lock. BusyFlag

2.3.条件变量

条件变量是POSIX线程模型提供的一种同步类型，和java中的等待通知机制类似。

虽然java中已经有了等待通知机制，但是为了减少在notify/notifyAll方法中

线程调度的开销，把一些不需要激活的线程屏蔽出去，引入了条件变量。

Java中2个（多个）条件变量可以是同一个互斥体（锁对象）。

参考：thread.lock.CondVar 条件变量类

常见的应用情形：

一个锁控制多个信号通道（例如：多个变量），虽然可以采用简单java等待通知机制，但是线程调度效率不高，而且线程可读性也不是太好，这时候可以采用创建一个锁对象(BusyFlag实例)，同时使用这个BusyFlag实例来创建多个条件变量(CondVar 实例)。

经常使用到CondVar类的地方是缓冲区管理，比如：管道操作之类的。先创建一个BusyFlag实例，然后创建CondVar 实例，用这个条件变量描述缓冲区是否为空，另外创建CondVar 实例作条件变量述缓冲区是否满。

现实中，马路的红绿灯，就可以采用条件变量来描述。

3. Java线程调度

3.1 Java优先级

java的优先级别共有10种，加上虚拟机自己使用的优先级别=0这种，总共11种。

大多数情况来说，java线程的优先级设置越高（最高=10），那线程越优先运行。

3.2. 绿色线程

线程运行在虚拟机内，操作系统根本不知道这类线程的存在。

线程是由虚拟机调度的。

3.3 本地线程

线程是由运行虚拟机的操作系统完成的。

3.4 Windows本地线程

操作系统，完全能够看得到虚拟机内的每一个线程，同时虚拟机的线程和操作系统的线程是一一对应的。Java的线程调度室由操作系统底层线程决定的。

在win32平台下，windows线程只有6个优先级别。和java线程优先级别对应如下：

Java线程优先级 Windows 95/nt/2000线程优先级

0 THREAD_ PRIORITY_IDLE

1(Thread.MIN_PRIORITY) THREAD_ PRIORITY_LOWEST

2 THREAD_ PRIORITY_LOWEST

3 THREAD_ PRIORITY_BELOW_NORMAL

4 THREAD_ PRIORITY_BELOW_NORMAL

5 (Thread.NORM_PRIORITY) THREAD_ PRIORITY _NORMAL

6 THREAD_ PRIORITY _ABOVE_NORMAL

7 THREAD_ PRIORITY _ABOVE_NORMA

8 THREAD_ PRIORITY _HIGHEST

9 THREAD_ PRIORITY _HIGHEST

10 (Thread.MAX_PRIORITY) THREAD_ PRIORITY _CRITICAL

3.5线程优先级倒置与继承

如果一个线程持有锁(假设该线程名字=ThreadA,优先级别=5)，另外一个线程(假设该线程名字=ThreadB,优先级别=7),现在该线程(ThreadA)处于运行状态，但是线程ThreadB申请需要持有ThreadA所获得的锁，这时候，为了避免死锁，线程A提高其运行的优先级别（提高到ThreadB的优先级别=7）,而线程ThreadB为了等待获得锁，降低线程优先级别(降低到ThreadA原来的优先级别=5).

上述的这种情况，对于ThreadA,继承了ThreadB的优先级别，这成为优先级别的继承；对于ThreadB暂时降低了优先级别，成为优先级别的倒置。

当然，一旦线程ThreadA持有的锁释放了，其优先级别也会回到原来的优先级别（优先级别=5）。线程ThreadB获得了相应的锁，那优先级别也会恢复到与原来的值(优先级别=7)。

3.6循环调度

具有同样优先级的线程相互抢占成为循环调度。

4.线程池

创建一个线程也是需要一定代价的,为了降低这个代价，采用了和普通对象池的思想建立线程池，以供系统使用。

线程消耗包括内存和其它系统资源在内的大量资源。除了 Thread 对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。除此以外，JVM 可能会为每个 Java 线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后，虽然线程之间切换的调度开销很小，但如果有很多线程，环境切换也可能严重地影响程序的性能。

使用线程池的方式是，先建立对象池，然后申请使用线程，程序线程运行，运行完毕，把线程返回线程池。

使用线程池的风险：同步错误和死锁，与池有关的死锁、资源不足和线程泄漏。

大家有空可以研究一下tomcat的线程池实现原理思想。

实际上是tomcat已经在从线程池的使用线程时候加上了事件处理机制。

个人认为，线程池之类的实现，一般不要自己实现，因为自己实现主要是稳定性等方面可能作的不够好。

可以参考 apache的jakarta-tomcat-5.5.6的相关代码，具体是：

jakarta-tomcat-connectors\util\java\org\apache\tomcat\util\threads的相关代码

5工作队列

使用工作队列的好处是不象直接使用线程池那样，当线城池中没有线程可以使用的时

候，使用者需要处于等待状态，不能进行其他任务的处理。

工作队列的工作原理是：

采用后台线程处理方式，客户端把任务提交给工作队列，工作队列有一组内部可以工作线程，这些工作线程从工作队列中取出任务运行，一个任务完成后，就从队列获取下一个任务进行处理。当工作队列中没有任务可以处理时候，工作线程就处于等待状态，直到获得新的任务时候，才进行新的处理。

java线程泄漏的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于线程池泄露、java线程泄漏的信息别忘了在本站进行查找喔。