精华内容
下载资源
问答
  • java oom 风险调查

    2019-03-14 19:20:14
    1.查看java进程号。 ps -ef|grep java 或者 jps ...2.生成堆dump文件快照:进程号25 ...jmap -dump:live,format=b,file=heap.hprof 25 ...4.查看自己java程序中设置堆的大小:从而来判断是否有内存泄漏的风险。 ...

    1.查看java进程号。

    ps -ef|grep java

    或者

    jps

     

    2.生成堆dump文件快照:进程号25

    jmap -dump:live,format=b,file=heap.hprof 25

     

    3.使用jvisualvm

    文件->导入文件进行查看

     


     

    4.查看自己java程序中设置堆的大小:从而来判断是否有内存泄漏的风险。

    展开全文
  • Executors类中封装好的创建线程池的方法使用方便,但是也有其局限性和风险性,所以我们可以使用 ThreadPoolExecutor 类中的构造方法手动创建线程池的实例, 从而可以根据我们的使用情况来指定参数,满足使用的同时又...

    介绍:

    线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。

    为什么要使用线程池?

    这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处:

    降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
    提高响应速度。 当任务到达时,任务可以不需要的等到线程创建就能立即执行。
    提高线程的可管理性。 线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
    
       
    • 1
    • 2
    • 3

    如何创建线程池?

    《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建,而是通过 new ThreadPoolExecutor 实例的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

    使用Executors哪里有风险?有什么风险?

    Executors 返回线程池对象的弊端如下:

    FixedThreadPool 和 SingleThreadExecutor : 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求,从而导致OOM。

    CachedThreadPool 和 ScheduledThreadPool : 允许创建的线程数量为 Integer.MAX_VALUE ,可能会创建大量线程,从而导致OOM。

    下面就分析

    分析源码:

    先看Executors类,这里先看Executors类调用了哪些方法,至于方法参数的意义,先不用管,后面有详细介绍:
    public class Executors {
    
    /**
     * 创建固定数量线程的线程池
     *
     * 这是最后一个参数--阻塞队列调用的方法,长度是Integer.MAX_VALUE
     * public LinkedBlockingQueue() {
     *    this(Integer.MAX_VALUE);
     * }
     *
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    
    
    /**
     * 创建只有一个线程的线程池
     *
     * 这是最后一个参数--阻塞队列调用的方法,长度也是Integer.MAX_VALUE
     * public LinkedBlockingQueue() {
     *    this(Integer.MAX_VALUE);
     * }
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    
    
    /**
     *创建一个缓冲线程池 
     *
     * 这是最后一个参数--阻塞队列调用的方法
     * public SynchronousQueue() {
     *    this(false);
     * }
     *
     * 它的第二个参数,maximumPoolSize 为Integer.MAX_VALUE
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    
    
    /**
     * Creates a thread pool that can schedule commands to run after a
     * given delay, or to execute periodically.
     *
     * 创建一个可以在给定延迟后再执行或定期执行命令的线程池
     *
     * ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的子类,代码如下:
     *
     public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor
        implements ScheduledExecutorService {
            
            //这是下面调用的构造方法,其实是调用了父类的构造方法,这些参数都是下面分析的参数
            public ScheduledThreadPoolExecutor(int corePoolSize) {
               super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
               new DelayedWorkQueue());
            }
            
     }
    
     *
     * @param corePoolSize the number of threads to keep in the pool,
     * even if they are idle
     * @return a newly created scheduled thread pool
     * @throws IllegalArgumentException if {@code corePoolSize < 0}
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    

    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89

    可以看到Executors类创建线程池的时候实际就是调用ThreadPoolExecutor类的构造方法来创建。

    再看ThreadPoolExecutor类:
    
    public class ThreadPoolExecutor extends AbstractExecutorService {
    

    /**
    * 其中一个构造方法:newFixedThreadPool时调用的
    *
    * Creates a new {@code ThreadPoolExecutor} with the given initial
    * parameters and default thread factory and rejected execution handler.
    * It may be more convenient to use one of the {@link Executors} factory
    * methods instead of this general purpose constructor.
    *
    * @param corePoolSize the number of threads to keep in the pool, even
    * if they are idle, unless {@code allowCoreThreadTimeOut} is set
    * @param maximumPoolSize the maximum number of threads to allow in the
    * pool
    * @param keepAliveTime when the number of threads is greater than
    * the core, this is the maximum time that excess idle threads
    * will wait for new tasks before terminating.
    * @param unit the time unit for the {@code keepAliveTime} argument
    * @param workQueue the queue to use for holding tasks before they are
    * executed. This queue will hold only the {@code Runnable}
    * tasks submitted by the {@code execute} method.
    * @throws IllegalArgumentException if one of the following holds:<br>
    * {@code corePoolSize < 0}<br>
    * {@code keepAliveTime < 0}<br>
    * {@code maximumPoolSize <= 0}<br>
    * {@code maximumPoolSize < corePoolSize}
    * @throws NullPointerException if {@code workQueue} is null
    */
    public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    Executors.defaultThreadFactory(), defaultHandler);
    }

    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    参数介绍:

    corePoolSize

    在线程池中保持的线程的数量,即使是这些线程没有被使用,除非设置了线程超时时间

    maximumPoolSize

    最大线程数量,当workQueue队列已满,放不下新的任务,再通过execute添加新的任务则线程池会再创建新的线程,线程数量大于corePoolSize但不会超过maximumPoolSize,如果超过maximumPoolSize,那么会抛出异常,如RejectedExecutionException。

    keepAliveTime和unit

    当线程池中线程数量大于workQueue,如果一个线程的空闲时间大于keepAliveTime,则该线程会被销毁。unit则是keepAliveTime的时间单位。

    workQueue

    阻塞队列,当线程池正在运行的线程数量已经达到corePoolSize,那么再通过execute添加新的任务则会被加到workQueue队列中,在队列中排队等待执行,而不会立即执行。

    为什么说
    FixedThreadPool 和 SingleThreadExecutor : 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求,从而导致OOM。
    CachedThreadPool 和 ScheduledThreadPool : 允许创建的线程数量为 Integer.MAX_VALUE ,可能会创建大量线程,从而导致OOM。
    再结合注释看Executors类中的传参就明白了!

    Executors中创建线程池:

    FixedThreadPool 和 SingleThreadExecutor 传入的最后一个参数阻塞队列 ”workQueue“,默认的长度是INTEGER.MAX_VALUE,而它们允许的最大线程数量又是有限的,所以当请求线程的任务过多线程不够用时,它们会在队列中等待,又因为队列的长度特别长,所以可能会堆积大量的请求,导致OOM。

    CachedThreadPool 和 ScheduledThreadPool 它们的阻塞队列长度有限,但是传入的第二个参数maximumPoolSize 为Integer.MAX_VALUE,这就意味着当请求线程的任务过多线程不够而且队列也满了的时候,线程池就会创建新的线程,因为它允许的最大线程数量是相当大的,所以可能会创建大量线程,导致OOM。

    总结:

    Executors类中封装好的创建线程池的方法使用方便,但是也有其局限性和风险性,所以我们可以使用 ThreadPoolExecutor 类中的构造方法手动创建线程池的实例, 从而可以根据我们的使用情况来指定参数,满足使用的同时又能规避风险。
    所以,说白了,使用Executors类创建线程池与使用ThreadPoolExecutor类的区别就是使用ThreadPoolExecutor类可以自定义传入我们设置的线程池的参数,更加灵活。

            </div>
    					<link href="https://csdnimg.cn/release/phoenix/mdeditor/markdown_views-258a4616f7.css" rel="stylesheet">
                      </div>
    
    展开全文
  • oom

    2016-12-09 13:42:14
    OOM(内存溢出) 情况一 处理bitmap资源不得当造成(压缩或者变换得到新bitmap) 解决方案 采用try catch处理方式,若出现异常再做压缩,期间采用弱引用方式处理。 example: WeakReferenceBitmap> ...

    OOM(内存溢出)

    情况一

    处理bitmap资源不得当造成(压缩或者变换得到新bitmap)

    解决方案

    采用try catch处理方式,若出现异常再做压缩,期间采用弱引用方式处理。 example:

            WeakReference<Bitmap> bitmapWeakReference;
            // First decode with inJustDecodeBounds=true to check dimensions
            final BitmapFactory.Options options = new BitmapFactory.Options();
            try {
                options.inJustDecodeBounds = true;
                BitmapFactory.decodeFileDescriptor(fd, null, options);
    
                // Calculate inSampleSize
                options.inSampleSize = calculateInSampleSize(options, reqWidth,
                        reqHeight);
    
                // Decode bitmap with inSampleSize set
                options.inJustDecodeBounds = false;
                // 弱引用处理图片 add leibing 2016/12/8
                bitmapWeakReference
                        = new WeakReference<Bitmap>(BitmapFactory.decodeFileDescriptor(fd, null, options));
                if (bitmapWeakReference != null && bitmapWeakReference.get() != null)
                    return bitmapWeakReference.get();
            }catch (OutOfMemoryError ex){
                // 压缩图片指定值 add by leibing 2016/12/8
                options.inSampleSize = options.inSampleSize + 4;
                options.inJustDecodeBounds = false;
                // 弱引用处理图片 add leibing 2016/12/8
                bitmapWeakReference
                        = new WeakReference<Bitmap>(BitmapFactory.decodeFileDescriptor(fd, null, options));
                if (bitmapWeakReference != null && bitmapWeakReference.get() != null)
                    return bitmapWeakReference.get();
            }

    情况二

    各种内存泄漏问题造成,主要有以下:

    单例造成的内存泄露
    解决方案

    1、将该属性的引用方式改为弱引用; 2、如果传入Context,使用ApplicationContext; example 泄漏代码片段

        // sington
        private static InstanceClass instance;
        // activity refer
        private Context mContext;
    
        /**
         * set activity refer
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param mContext activity refer
         * @return
         */
        public void setRefer(Context mContext){
            this.mContext = mContext;
        }
    
        /**
         * constructor
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param
         * @return
         */
        private InstanceClass(){
        }
    
        /**
         * sington
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param
         * @return
         */
        public static InstanceClass getInstance(){
            if (instance == null){
                synchronized (InstanceClass.class){
                    if (instance == null)
                        instance = new InstanceClass();
                }
            }
    
            return instance;
        }

    Solution:使用WeakReference

        // sington
        private static InstanceClass instance;
        // activity refer
        private WeakReference<Context> mContextWeakRef;
    
        /**
         * set activity refer
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param mContext activity refer
         * @return
         */
        public void setRefer(Context mContext){
            mContextWeakRef = new WeakReference<Context>(mContext);
        }
    
        /**
         * constructor
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param
         * @return
         */
        private InstanceClass(){
        }
    
        /**
         * sington
         * @author leibing
         * @createTime 2016/12/9
         * @lastModify 2016/12/9
         * @param
         * @return
         */
        public static InstanceClass getInstance(){
            if (instance == null){
                synchronized (InstanceClass.class){
                    if (instance == null)
                        instance = new InstanceClass();
                }
            }
    
            return instance;
        }
    InnerClass匿名内部类
    解决方案

    1、将内部类变成静态内部类; 2、如果有强引用Activity中的属性,则将该属性的引用方式改为弱引用; 3、在业务允许的情况下,当Activity执行onDestory时,结束这些耗时任务; example 泄漏代码片段

    public class InnerClassActivity extends Activity{
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // start a thread to work
            new InnerThread().start();
        }
    
        /**
         * @interfaceName: InnerThread
         * @interfaceDescription: custom thread
         * @author: leibing
         * @createTime: 2016/12/9
         */
        class InnerThread extends Thread{
            @Override
            public synchronized void start() {
                super.start();
            }
    
        }
    }

    Solution:使用WeakReference + static

    public class InnerClassActivity extends Activity{
        // 图片资源
        private Drawable mDrawable;
        // inner thread
        private InnerThread mInnerThread;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // init drawable
            mDrawable = getResources().getDrawable(R.drawable.ic_launcher);
            // start a thread to work
            mInnerThread = new InnerThread(mDrawable);
            mInnerThread.start();
        }
    
        @Override
        protected void onDestroy() {
            if (mInnerThread != null)
                mInnerThread.setIsRun(false);
            super.onDestroy();
        }
    
        /**
         * @interfaceName: InnerThread
         * @interfaceDescription: custom thread
         * @author: leibing
         * @createTime: 2016/12/9
         */
        static class InnerThread extends Thread{
            // weak ref
            public WeakReference<Drawable> mDrawableWeakRef;
            // is run
            private boolean isRun = true;
    
            /**
             * constructor
             * @author leibing
             * @createTime 2016/12/9
             * @lastModify 2016/12/9
             * @param mDrawable 图片资源(存在对页面的引用风险)
             * @return
             */
            public InnerThread(Drawable mDrawable){
              mDrawableWeakRef = new WeakReference<Drawable>(mDrawable);
            }
    
            /**
             *  set is run
             * @author leibing
             * @createTime 2016/12/9
             * @lastModify 2016/12/9
             * @param isRun
             * @return
             */
            public void setIsRun(boolean isRun){
                this.isRun = isRun;
            }
    
            @Override
            public void run() {
                while (isRun){
                    // do work
                    try {
                        // sleep one second
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
            @Override
            public synchronized void start() {
                super.start();
            }
        }
    }
    Activity Context 的不正确使用
    解决方案

    1、使用ApplicationContext代替ActivityContext,因为ApplicationContext会随着应用程序的存在而存在,而不依赖于activity的生命周期; 2、对Context的引用不要超过它本身的生命周期,慎重的对Context使用“static”关键字。Context里如果有线程,一定要在onDestroy()里及时停掉。 example 泄漏代码片段

    public class DrawableActivity extends Activity{
        // static drawable 
        private static Drawable leakDrawable;
    
        @Override
        protected void onCreate(Bundle state) {
            super.onCreate(state);
            TextView label = new TextView(this);
            // init drawable
            if (leakDrawable == null) {
                leakDrawable = getResources().getDrawable(R.drawable.ic_launcher);
            }
            // view set drawable
            label.setBackgroundDrawable(leakDrawable);
    
            setContentView(label);
        }
    }

    Solution:

    public class DrawableActivity extends Activity{
        // static drawable
        private static Drawable leakDrawable;
    
        @Override
        protected void onCreate(Bundle state) {
            super.onCreate(state);
            TextView label = new TextView(this);
            // init drawable
            if (leakDrawable == null) {
                leakDrawable = getApplicationContext().getResources().getDrawable(R.drawable.ic_launcher);
            }
            // view set drawable
            label.setBackgroundDrawable(leakDrawable);
    
            setContentView(label);
        }
    }
    Handler引起的内存泄漏
    解决方案

    1、可以把Handler类放在单独的类文件中,或者使用静态内部类便可以避免泄露; 2、如果想在Handler内部去调用所在的Activity,那么可以在handler内部使用弱引用的方式去指向所在Activity.使用Static + WeakReference的方式来达到断开Handler与Activity之间存在引用关系的目的。 example 泄漏代码片段

    public class HandlerActivity extends Activity{
        // custom handler
        private CustomHandler mHandler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // init custom handler
            mHandler = new CustomHandler();
            // sendMsg
            Message msg = new Message();
            mHandler.sendMessage(msg);
        }
    
        /**
         * @interfaceName: CustomHandler
         * @interfaceDescription: custom handler
         * @author: leibing
         * @createTime: 2016/12/9
         */
        class CustomHandler extends Handler{
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        }
    }

    Solution(static + weakRef):

    public class HandlerActivity extends Activity{
        // custom handler
        private CustomHandler mHandler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // init custom handler
            mHandler = new CustomHandler();
            // sendMsg
            Message msg = new Message();
            mHandler.sendMessage(msg);
        }
    
        /**
         * @interfaceName: CustomHandler
         * @interfaceDescription: custom handler
         * @author: leibing
         * @createTime: 2016/12/9
         */
        static class CustomHandler extends Handler{
            // weak ref
            private WeakReference<Context> mContextWeakRef;
    
            /**
             * constructor
             * @author leibing
             * @createTime 2016/12/9
             * @lastModify 2016/12/9
             * @param mContext activity ref
             * @return
             */
            public CustomHandler(Context mContext){
                mContextWeakRef = new WeakReference<Context>(mContext);    
            }
    
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (mContextWeakRef != null && mContextWeakRef.get() != null){
                    // do work
                }
            }
        }
    }
    注册监听器的泄漏
    解决方案

    1、使用ApplicationContext代替ActivityContext; 2、在Activity执行onDestory时,调用反注册;

    Cursor,Stream没有close,View没有recyle;
    解决方案

    资源性对象比如(Cursor,File文件等)往往都用了一些缓冲,我们在不使用的时候,应该及时关闭它们,以便它们的缓冲及时回收内存。它们的缓冲不仅存在于 java虚拟机内,还存在于java虚拟机外。如果我们仅仅是把它的引用设置为null,而不关闭它们,往往会造成内存泄漏。因为有些资源性对象,比如SQLiteCursor(在析构函数finalize(),如果我们没有关闭它,它自己会调close()关闭),如果我们没有关闭它,系统在回收它时也会关闭它,但是这样的效率太低了。因此对于资源性对象在不使用的时候,应该调用它的close()函数,将其关闭掉,然后才置为null. 在我们的程序退出时一定要确保我们的资源性对象已经关闭。

    集合中对象没清理造成的内存泄漏
    解决方案

    在Activity退出之前,将集合里的东西clear,然后置为null,再退出程序。

    private List<String> mData;    
    public void onDestory() {        
        if (mData!= null) {
            mData.clear();
            mData= null;
        }
    }
    WebView造成的泄露
    解决方案

    为webView开启另外一个进程,通过AIDL与主线程进行通信,WebView所在的进程可以根据业务的需要选择合适的时机进行销毁,从而达到内存的完整释放。

    类型转换错误

    解决方案

    首先判断类型转换前数据是否符合转化后的数据再做处理。 example: 字符串转整型数字 首先判断字符串是否为数字字符串,然后再转换,此时最好加上try catch处理,防止崩溃。

    展开全文
  • 记录一次排查oom

    2020-10-28 09:29:38
    查看dump分析发现是服务接入cat引起的,接了有一段时间了现在才oom,虽然内存配小了,但是还是要确定下加大内存会不会还有oom风险。 开始分析是TcpSocketSender中的DefaultMessageQueue占用了大量的内存。 在...

    预发环境服务发生oom,乍一看才600多MB就oom?what?why?

    吓得马上查看了下堆大小发现才给的512MB,真是扣,这个要扩一下。

    查看dump分析发现是服务接入cat引起的,接了有一段时间了现在才oom,虽然内存配小了,但是还是要确定下加大内存会不会还有oom风险。

    开始分析是TcpSocketSender中的DefaultMessageQueue占用了大量的内存。

    在代码中查找:com.dianping.cat.message.io.TcpSocketSender。

    该类实现了Task,Task继承了Runnable就一定有run方法。
    
    
    TcpSocketSender类中DefaultMessageQueue是个BlockingQueue的包装类,初始化时队列大小给的5000,也跟dump中对得上,限制了队列大小起码不会一直增长吃内存。下面要找下什么原因导致队列满了。

     查看哪里做了入队、出队操作导致队列占用内存,优先看下run方法,该方法中会从m_queue取出一个元素通过m_channelManager拿到一个channel,m_channelManager是一个netty EventLoopGroup,channel不会空会将队列中的元素发送出去,为空则会重新放回去,哦呵,灵光一闪。

    占时排查channel为空导致队列无法及时消除,后续查看发现是cat服务挂了导致channel获取为null,然后就一直循环。

    解决方式:cat做高可用,服务进行集群部署。

     

    展开全文
  • OOM

    千次阅读 2012-12-19 22:50:45
    OOM现象: 05:15:04.764: ERROR/dalvikvm-heap(264): 3528000-byte external allocationtoo large for … 05:15:04.764: ERROR/(264): VM won’t let us allocate 3528000 bytes 05:15:04.764: DEBUG/skia...
  • 前面一节重点分享了Linux的内存分配策略,基于上述的分配策略,为了规避超售的风险,Linux采了一种OOM Killer的机制,即系统可用内存(包括Swap)即将使用完之前,选择性的Kill掉一些进程以求释放一些内存
  • 前段时间碰到 postgres 主进程被 oom killer 杀掉的情况,初步研究了下. postgres 是 postgresql 的主进程,如果它被 oom killer 干掉了,那 postgresql 数据库就关闭了. 其他进程异常了就会进行 crash recovery,自动...
  • oom处理

    2016-03-14 00:11:43
    如何避免 OOM 异常 OOM 内存溢出,想要避免 OOM 异常首先我们要知道什么情况下会导致 OOM 异常。 1、图片过大导致 OOM Android 中用 bitmap 时很容易内存溢出,比如报如下错误:Java.lang.OutOfMemoryError :...
  • OOM详解

    2015-10-10 23:25:35
    OOM现象: 05:15:04.764: ERROR/dalvikvm-heap(264): 3528000-byte external allocationtoo large for … 05:15:04.764: ERROR/(264): VM won’t let us allocate 3528000 bytes 05:15:04.764: DEBUG/skia...
  • 什么是OOM?如何解决OOM问题!

    万次阅读 多人点赞 2018-07-12 21:22:54
    1、什么是OOM? 2、为什么会有OOM? 3、为什么Android会有APP的内存限制 4、有GC自动回收资源,为什么还会有OOM? 5、怎么来避免OOM产生呢? 1、什么是OOM?  程序申请内存过大,虚拟机无法满足我们,然后...
  • 常见OOM现象

    2019-09-25 22:43:57
    常见OOM现象 《java 特种兵 上册》 3.6 常见的OOM现象( 136-146页),看此节后的总结。 OOM的实际场景是很多的,这里介绍常见的,同时结合网络与实际测试中的一些资料信息。 一.HeapSize OOM(堆空间内存溢出) ...
  • Android加载图片 避免图片 bitmap OOM
  • OOM Killer机制

    2021-05-24 11:10:18
    oom killer 概念 oom killer是内核设计的一种机制,在内存不足时选择一个占用内存较大的进程把他杀死,释放这一部分内存来满足内存请求的的需求。 oom(out of memory) OOM(Out of Memory)指Linux在无可用内存时的...
  • OOM异常详解

    2020-03-12 23:01:19
    1.什么是OOMOOM,java.lang.OutOfMemoryError 错误,也就是java内存溢出错误。一般当jvm虚拟机内存不够用的时候,就会抛出该错误。 2.OOM的各种情况 jvm内存模型,分为5大部分,堆,栈,方法区,本地方法栈和...
  • Android 如何避免OOM

    2017-01-05 13:52:28
    Android 如何避免OOM
  • 我们在编写Android程序的时候经常要用到...大家应该知道,我们编写的应用程序都是有一定内存限制的,程序占用了过高的内存就容易出现OOM(OutOfMemory)异常。我们可以通过下面的代码看出每个应用程序最高可用内存是多少
  • java OOM

    千次阅读 2015-09-25 10:22:02
    上述区域中,除了程序计数器,其他在VM Spec中都描述了产生OutOfMemoryError(下称OOM)的情形,那我们就实战模拟一下,通过几段简单的代码,令对应的区域产生OOM异常以便加深认识,同时初步介绍一些与内存相关的...
  • 内存溢出OOM

    2016-04-08 13:03:00
    如何避免OOM 异常? 想要避免OOM 异常首先我们要知道什么情况下会导致OOM 异常。 1、图片过大导致OOM Android 中用bitmap 时很容易内存溢出,比如报如下错误:Java.lang.OutOfMemoryError : bitmap sizeexceeds ...
  • 常见OOM 原因及解决方案

    千次阅读 2019-11-01 23:16:35
    本文总结了常见的 OOM 原因及其解决方法,如下图所示。如有遗漏或错误,欢迎补充指正。 1、Java heap space 当堆内存(Heap Space)没有足够空间存放新创建的对象时,就会抛出java.lang.OutOfMemoryError:Java...
  • Android OOM优化

    2017-03-04 11:05:10
    转载 ...1.什么是OOM? 03-21 21:05:28.771: E/dalvikvm-heap(13316): Out of memory on a 10485776-byte allocation. 03-21 21:05:28.779: E/AndroidRuntime(13316):
  • 内存泄漏 OOM

    2016-06-10 19:11:22
    如果我们的查询结果集比较小,对内存的消耗不容易被发现,只有在常时间大量操作的情况下才会复现内存问题,这样就会给以后的测试和问题排查带来困难和风险。 三、一些不良代码成内存压力  有些代码并不...
  • android 避免OOM

    2016-05-30 15:51:20
    如果我们的查询结果集比较小, 对内存的消耗不容易被发现,只有在常时间大量操作的情况下才会复现内存问题,这样就会给以后的测试和问题排查带来困难和风险,记得try catch后,在finally方法中关闭连接 ...
  • 如何避免 OOM 异常

    千次阅读 2016-11-13 14:54:16
    如何避免 OOM 异常
  • 如何避免OOM异常

    2016-11-28 00:29:33
    如何避免OOM异常 OOM 内存溢出,想要避免 OOM 异常首先我们要知道什么情况下会导致OOM异常。 1、图片过大导致OOM Android 中 用 bitmap 时 很 容 易 内 存 溢 出 , 比 如 报 如 下 错 误 : Java.lang....
  • OOM 通常是指Out of Memory (OOM) killer. 如何避免OOM 如何优化OOM OOM评分机制 vm.panic_on_oom = 0|1 默认0 /proc/PID/oom_score vm.min_free_kbytes
  • OOM和内存优化总结 什么是OOM? OOM 即 (java.lang.OutOfMemoryError), JVM没有足够内存给对象分配空间,超过jvm的堆空间最大值(-Xmx参数),此异常就会被触发,导致应用强制被杀死。
  • JVM发生OOM问题定位与分析

    千次阅读 2020-08-10 11:01:57
    什么是OOM

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,816
精华内容 4,326
关键字:

oom风险