Java中JVM的内存回收问题

如下这种情况哪几个对象的内存会被回收
a.v=b;
b.v=c;
c.v=d;
d.v=a;
(a.v意为对象a的v属性)

1个回答

d.v=a;
从这里看,d a 是可达的。
进一步 b c 也可以通过a b的v字段访问。
所以如果d没有回收,那么abc也不会回收。

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
jvm需要做哪些准备才开始做内存回收操作?
java中有内存回收! jvm需要做哪些准备才开始做内存回收操作?
如何避免jvm垃圾回收的抖动问题
当系统运行一段时间,jvm需要垃圾回收的时候,发现整个系统会“卡住”一段时间,几乎不能处理任何的请求,然后发现系统所占用的内存急剧下降,应该是被jvm回收了,不知道是系统架构问题还是jvm的问题,但这种“抖动”的确影响太大了,如何解决这个问题呢?从业务架构方向考虑还是java代码写的不够好? 谢谢指点!
内存溢出,Java heap space,jvm垃圾回收好像没有用,内存一直在加
读取大图片的时候 BufferedImage image = ImageIO.read(is); 这个老报错,图片量一多起来就内存溢出了,内存一直增加,在eclipse配置了垃圾回 收也不行,还是一直增,不知道怎么解决,大神们指导下了 ![图片说明](https://img-ask.csdn.net/upload/201707/18/1500371436_732776.png) ![图片说明](https://img-ask.csdn.net/upload/201707/18/1500371454_266084.png)
服务器大内存jvm配置.。。
公司现在要上线java项目,提供了32G的内存机器,8核,我要怎么设置jvm的大小, 如果设置的太大会不会gc回收的时间过长造成系统卡顿或者内存泄露,怎么在内存 利用和性能调优中权衡呢,就大神解答
JVM相关基础面试题--请大神解答
(单选)下列关于JVM说法,错误的是() A.JVM通过专门的线程实现内存的回收。 B.使用java命令时,可以通过参数来设置分配JVM的内存大小。 C.JRE包括JVM及Java核心类库。 D.目前主流版本JVM通过纯解释的方式运行Java字节码。 为什么正确答案是D?B错在哪里了?请热心大神帮我看看
【java】jmap -histo pid 输出的[B 占用很高,请问问题会在哪里?
公司目前的程序是解析excel表格内容,使用到了poi sax方式解析,但是在监控的过程中发现堆内存B的占用非常高,使用mat工具也告诉B可能存在内存泄漏问题。 代码中那些操作会导致这个问题呢?代码中只使用了一个inputstream来保存文件,而且使用后也关闭了 是在找不到,但是B占了相当多的空间 b就是byte数据(下面这个不是我的图,是我找的一个例图,就是B那个地方,我这里显示的是占用最高的,我不知道我的程序哪里写错了会导致这种情况) ``` num #instances #bytes class name ---------------------------------------------- 1: 1169837 131659368 [C 2: 25945 38337824 [I 3: 31548 29407968 [B 4: 1164546 27949104 java.lang.String 6: 91313 12829072 <constMethodKlass> 7: 12395 12404880 [S 8: 91313 11700288 <methodKlass> 9: 7525 9303112 <constantPoolKlass> 10: 7525 5606808 <instanceKlassKlass> 11: 6043 5028288 <constantPoolCacheKlass> 12: 10048 2007888 [Ljava.lang.Object; 14: 3507 1707048 <methodDataKlass> 15: 8132 980616 java.lang.Class 16: 26854 859328 java.util.HashMap$Entry 17: 12368 699296 [[I 18: 14135 452320 java.util.concurrent.ConcurrentHashMap$HashEntry 19: 20883 334128 java.lang.Object 20: 590 316240 <objArrayKlassKlass> 21: 1757 305904 [Ljava.util.HashMap$Entry; 22: 2809 224720 net.sf.ehcache.Element 23: 1992 223104 java.net.SocksSocketImpl 24: 2668 213440 java.lang.reflect.Method 26: 5932 183928 [Ljava.lang.String; 27: 7588 182112 java.util.concurrent.ConcurrentSkipListMap$Node 28: 7317 175608 java.lang.Long 29: 5303 169696 java.util.Hashtable$Entry 30: 6778 162672 java.util.ArrayList 31: 3931 157240 java.lang.ref.SoftReference 32: 2972 118880 java.util.LinkedHashMap$Entry 33: 1565 112680 org.apache.commons.pool2.impl.DefaultPooledObject 34: 2817 112680 net.sf.ehcache.store.chm.SelectableConcurrentHashMap$HashEntry 35: 2243 107664 java.util.HashMap 36: 2592 103680 java.util.TreeMap$Entry 37: 3214 102848 java.lang.ref.WeakReference 38: 1565 100160 redis.clients.jedis.Client 39: 4155 99720 java.util.LinkedList$Node 40: 1986 95328 java.net.SocketInputStream 41: 414 92952 [Ljava.util.concurrent.ConcurrentHashMap$HashEntry; 42: 2275 91000 java.lang.ref.Finalizer 43: 1161 83592 java.lang.reflect.Constructor 44: 757 78728 java.io.ObjectStreamClass 45: 1587 76176 java.net.SocketOutputStream 46: 1189 66584 java.beans.MethodDescriptor 47: 2770 66480 org.apache.commons.pool2.impl.LinkedBlockingDeque$Node 48: 388 66368 [Ljava.util.Hashtable$Entry; 49: 1989 63648 java.net.Socket 50: 749 53928 java.lang.reflect.Field ... ... 2947: 1 16 sun.misc.Launcher 2948: 1 16 org.codehaus.jackson.map.ser.std.DateSerializer 2949: 1 16 org.apache.phoenix.schema.types.PDataType$2 2950: 1 16 org.springframework.data.redis.connection.convert.StringToRedisClientInfoConverter Total 3090439 316004152 ```
通过Java RMI的定时GC触发,JVM垃圾回收就无法自动触发FULL GC了吗?
Java RMI的定时GC触发机制,可通过:-XX:+DisableExplicitGC来禁止或通过 -Dsun.rmi.dgc.server.gcInterval=3600000来控制触发的时间。 那么问题来了堆栈内存满了,是否就不会自动触发FULL GC了。 目前系统几次宕机,看内存监控均为堆栈满了,但是没能触发FULL GC。 看应用服务启动配置中有Dsun.rmi.dgc.server.gcInterval=3600000这个配置,麻烦懂得人帮确认下我上面的疑问。 如果是,那如何定时触发GC并且能够在堆栈快满了也能自动触发GC,应该如何配置。
java 垃圾回收 Mark-and-Compact 算法 去碎片如何操作堆中内存的
在压缩堆内存阶段,遍历堆中所有对象并将存活对象重新放入连续的内存地址的 过程中,如果某个存活对象即将放入的地址中存有另一个还没有被移动的存活的对象, java jvm如何进行操作呢? 我看的算法中没有给此方面的信息。它只说存活对象放入 连续的堆中! 大神!!!!求助!!!!!!!!!
tomcat7 java7 内存溢出 回收不掉
最近做压力测试5000个线程并发上传文件到TOMCAT服务器,tomcat版本是7,JAVA为1.7.0_25,都是64位 ,指定的JVM参数是 -Xmn800M -Xms1024M -Xmx1333M **自己在WINDOS7 上测试没什么问题,大版本都一样,WIN7用的JAVA 1.7_79**,部署在LINUX上就会导致卡死,系统是64位。堆内存一直爆满,垃圾回收器也回收不掉,一直在FULLGC,查看堆,看到好多字节数组占用空间,好像是 这些在引用: java.nio.HeapByteBuffer 实例数 10041 org.apache.commons.io.output.ByteArrayOutputStream 实例数 373088 org.apache.commons.io.fileupload.disk.DiskFileItem 实例数 373088 GC信息: S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT 68800.0 70656.0 0.0 0.0 675904.0 584951.8 546816.0 546814.6 29824.0 29543.5 39 3.176 206 341.438 344.614 可以看出,堆满了,也回收不掉。 停掉客户端后,不在做压力测试,并手动执行GC。数据如下: S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT 68800.0 70656.0 0.0 0.0 675904.0 12577.3 546816.0 44629.5 29824.0 29543.5 39 3.176 207 341.623 344.799 内存是下来了。 ## 再次发起压力测试 GC信息,堆内存信息变的很奇怪,如下: S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT 273024.0 273024.0 0.0 0.0 273152.0 273152.0 546816.0 546814.6 29824.0 29551.7 91 8.096 274 411.228 419.324 为什么堆内存是这样的,S0去内存这么大,EC区这么小。然后看到整个堆内存都没超过上次测试的最高,也是一直回收不掉。求解!~~~~~~~~~~~
请教一个JVM内存优化的问题
<p>自己写的一个WEB爬虫程序,程序方面的优化我自己感觉做的不错了,各种对象的使用都想办法不让内存浪费。 <br />但还是吃内存吃的很厉害 <br />我想主要的消耗在于,对于每一个爬下来的网页,都要变成String在内存中分析超链接,这个估计很大。 <br />另外对于每一个分析到的URL,都需要保存起来。 <br /><br /><br />我当前使用的内存优化参数如下 <br />-Xms1024M -Xmx1024M -Xmn512M -Xss128K -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseParallelOldGC -XX:MaxPermSize=128M -XX:NewSize=128M -XX:MaxNewSize=128M -XX:SurvivorRatio=8 <br /><br />机器内存是1G。。上面那堆参数,除了最大最小堆内存我也是不求甚解,不是非常明白我设置了什么。网上搜答案也是五花八门,希望大家能推荐一个内存优化参数的文章 <br />另外我上面设置的参数有哪些方面可以优化,或者哪些地方写的不对。 <br /><br />核心的代码我都贴到下面:(我是刚入门的菜鸟,大家别笑话我写的差哦) <br /><br />这个是主类,负责控制,那个monitor大家就当做System.out.println,其实就是</p> <pre name="code" class="java">package com.wood.core; import java.util.concurrent.*; import java.util.*; import com.wood.core.monitor.*; public class CrawlerController implements Runnable { //一个类,用来管理URL,由各抓取线程共享 private URLMap urlmap; //已成功处理URL总数 private int count; //目标完成任务总数 private int total; //管理所有的抓取线程,必要时进行关闭,由于抓取线程存在I/O读取,而I/0读取中的线程是不可中断的,需调用线程的cancel函数 private Crawler[] crawlers; //线程工厂,可以监视产生的线程工作状态 private CrawlerFactory factory; //线程数目 private int threadMax; //当前活动线程 private int threadActive; //线程执行器 private ExecutorService exec; //当系统关闭时取消 private boolean canceled; public CrawlerController(String seed) { this(seed,20,10000); } public CrawlerController(List&lt;string&gt; seeds) { this(seeds,20,10000); } public CrawlerController(String seed,int threadNum) { this(seed,threadNum,10000); } public CrawlerController(List&lt;string&gt; seeds,int threadNum) { this(seeds,threadNum,10000); } public CrawlerController(String seed,int threadNum,int total) { //初始化URLMap,保存抓取启始位置 urlmap=new URLMap(seed); init(threadNum, total); } public CrawlerController(List&lt;string&gt; seeds,int threadNum,int total) { urlmap=new URLMap(seeds); init(threadNum, total); } //构造 private void init(int threadNum,int total) { //初始完成URL总数为0 count=0; //设置目标完成总数 this.total=total; threadMax=threadNum; threadActive=threadNum; //初始化工作线程 crawlers=new Crawler[threadMax]; String id="Crawler "; for(int i=0;i&lt;threadmax;i++) crawlers[i]="new" crawler(id+(i+1),this,urlmap);="" factory="new" crawlerfactory();="" exec="Executors.newCachedThreadPool(factory);" canceled="false;" }="" 检查当前工作线程状态,并打印系统状态="" private="" boolean="" check()="" {="" if(canceled)="" return="" false;="" int="" count="getCount();" if(count=""&gt;total) { MonitorHolder.getMonitor().print("已抓取"+COUNT+"页面,完成目标任务"+total+"页面\n"); cancel(); return false; } threadActive=factory.getActive(); /*if(threadActive&lt;=0) { MonitorHolder.getMonitor().print("无活动工作线程,抓取任务提前结束\n"); cancel(); return false; }*/ MonitorHolder.getMonitor().print_status("统计信息:成功抓取"+COUNT+"页面,当前活动线程为"+threadActive+"个\n"); return true; } //结束抓取 public void cancel() { //调用每个抓取线程的离开方法 for(Crawler cw:crawlers) cw.cancel(); //销毁工厂 factory.destory(); exec.shutdownNow(); MonitorHolder.getMonitor().print("成功结束抓取工作,共抓取"+getCount()+"页面\n"); this.canceled=true; } public synchronized void count() { count++; } public synchronized int getCount() { return count; } public int getTotal() { return total; } public URLMap getMap() { return urlmap; } @Override public void run() { while(!Thread.currentThread().isInterrupted() &amp;&amp; !canceled) { try { MonitorHolder.getMonitor().print("初始化完毕\n"); MonitorHolder.getMonitor().print("开始抓取工作\n"); for(Crawler cw:crawlers) exec.execute(cw); int check_count=0; while (check()){ TimeUnit.SECONDS.sleep(5); check_count++; if(check_count==24) { //每2分钟把待处理URL队列打乱一次 urlmap.shuffle(); MonitorHolder.getMonitor().print("控制信息!!!待抓取URL顺序将打乱\n"); check_count=0; System.gc(); } } } catch (InterruptedException e) { MonitorHolder.getMonitor().print("抓取工作被中断\n"); cancel(); } } } public static void main(String[] args) { List&lt;string&gt; seeds=new ArrayList&lt;string&gt;(15); //问问的各个分类 seeds.add("http://wenwen.soso.com/"); seeds.add("http://wenwen.soso.com/z/c1879048192.htm"); seeds.add("http://wenwen.soso.com/z/c1090519040.htm"); seeds.add("http://wenwen.soso.com/z/c1627389952.htm"); seeds.add("http://wenwen.soso.com/z/c855638016.htm"); seeds.add("http://wenwen.soso.com/z/c1191182336.htm"); seeds.add("http://wenwen.soso.com/z/c1191182336.htm"); seeds.add("http://wenwen.soso.com/z/c620756992.htm"); seeds.add("http://wenwen.soso.com/z/c553648128.htm"); seeds.add("http://wenwen.soso.com/z/c385875968.htm"); seeds.add("http://wenwen.soso.com/z/c687865856.htm"); seeds.add("http://wenwen.soso.com/z/c16777216.htm"); seeds.add("http://wenwen.soso.com/z/c318767104.htm"); seeds.add("http://wenwen.soso.com/z/c150994944.htm"); seeds.add("http://wenwen.soso.com/z/c922746880.htm"); seeds.add("http://wenwen.soso.com/z/c83886080.htm"); CrawlerController controller=new CrawlerController(seeds,5,2000000); List&lt;string&gt; format=new ArrayList&lt;string&gt;(10); //问问回答问题的格式 format.add("http://wenwen.soso.com/z/q"); controller.getMap().addLimit(format); Thread thread=new Thread(controller); thread.start(); } } </pre> <p><br /></p> <pre name="code" class="java">package com.wood.core; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.regex.*; import java.io.*; import java.net.*; import com.wood.core.monitor.*; public class Crawler implements Runnable { //抓取线程ID private String id; //控制器 private CrawlerController controller; //URL,供各线程共享 private URLMap urlmap; private boolean canceled; //保存抓取的网页内容,用于分析超链接 private String content; //字符集 private String charset; //匹配超链接的正则表达式 private String link_reg="&lt;a\\s+(.*?)href\\s*=\\s*\"?(.*?)[\"(\\s*?)](.*?)&gt;"; private Pattern link_pattern=Pattern.compile(link_reg,Pattern.CASE_INSENSITIVE); //匹配字符集的正则表达式 private String charset_reg="&lt;meta\\s+http-equiv=\"content-type\"\\s+content=\"text html;="" charset="(.*?)\&amp;quot;(.*?)"&gt; "; private Pattern charset_pattern=Pattern.compile(charset_reg, Pattern.CASE_INSENSITIVE); private Pattern dir_path_pattern=Pattern.compile("^\\w+$", Pattern.CASE_INSENSITIVE); //保存当前抓取的URL的主机 private String host; //生成待建立的文件夹名 private String host_path; //抓取网页的根目录 private String root_path="E:\\web"; private File root_dir=new File(root_path); //输入来自URL,输出到文件 private InputStreamReader in=null; private OutputStreamWriter out=null; //输入输出缓冲区 private char[] buf=new char[10240]; //网页内容缓冲区 private StringBuilder contentbuilder=new StringBuilder(1024*1024); //通过一个URL,下载网页内容 private void download(URL url) { in=null; out=null; //建立抓取文件 String urlfile=url.getFile(); if(urlfile.endsWith("/")) urlfile+="indexindex"; File file=new File(host_path,urlfile); File file_dir=new File(file.getParent()); if(!file_dir.exists()) file_dir.mkdirs(); MonitorHolder.getMonitor().print(id+"开始准备下载"+url.toString()+"\n"); try { //打开链接 URLConnection conn=url.openConnection(); //超时30秒 conn.setConnectTimeout(30000); conn.setDoOutput(true); //不是HTML不下载 /*String type=conn.getContentType(); if( (type==null)|| (!type.equals("text/html")) ) return;*/ //将网页内容的缓冲区清空 contentbuilder.setLength(0); in=new InputStreamReader(conn.getInputStream(),charset); out=new OutputStreamWriter(new FileOutputStream(file),charset); int len; //读取网页内容,并写入文件,保存到网页内容缓冲里面 while((len=in.read(buf, 0, 10240)) &gt;0) { out.write(buf, 0, len); //append可以减小系统损耗 contentbuilder.append(buf, 0, len); } out.flush(); //将网页内容缓冲区的内容读到content中,用于分析 content=null; content=contentbuilder.toString(); } catch (IOException e) { MonitorHolder.getMonitor().print("错误!!!"+id+"下载页面"+url.toString()+"错误\n"); } finally{ try { if(in!=null) in.close(); if(out!=null) out.close(); } catch (IOException e) { } in=null; out=null; } } public Crawler(String id,CrawlerController controller,URLMap urlmap) { this.id=id; this.controller=controller; this.urlmap=urlmap; this.charset="utf-8"; canceled=false; MonitorHolder.getMonitor().print(id+"就绪\n"); } //设置字符集,通过正则表达式获取字符集格式 //为了性能,该功能并未使用 private void setCharset() { Matcher matcher=charset_pattern.matcher(content); String CHARSET="GB2312"; if(matcher.find()) CHARSET=matcher.group(1).trim(); this.charset=CHARSET; try { content=new String(content.getBytes("GB2312"),CHARSET); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } //从网页内容中分析超链接 private List&lt;string&gt; retrieveLinks(URL url) { List&lt;string&gt; urls=new LinkedList&lt;string&gt;(); if(content==null) return urls; Matcher matcher=link_pattern.matcher(content); String link; String host_reg="http://"+host; String host_nowww; if(host.contains("www")) host_nowww=host.substring(host.lastIndexOf("w")+2); else { host_nowww=host; } while(matcher.find()) { //通过抓取第1组的内容 link=matcher.group(2).trim().toLowerCase(); if (link.length() &lt; 1) { continue; } //网页内部链接,忽略 if (link.charAt(0) == '#') { continue; } //发送邮件链接,忽略 if (link.indexOf("mailto:") != -1) { continue; } if (link.toLowerCase().indexOf("javascript") != -1) { continue; } //分析绝对地址或相对地址 if (link.indexOf("://") == -1){ if (link.charAt(0) == '/') //处理绝对地址 link = "http://" + host+ link; else if(link.startsWith("./")) link="http://" + host+ link.substring(1); else { String file = url.getFile(); String file_path=file.substring(0, file.lastIndexOf('/')); while(link.startsWith("../")) { link=link.substring(link.indexOf("/")+1); file_path=file_path.substring(0, file_path.lastIndexOf("/")); } link="http://"+host+file_path+"/"+link; } } int index = link.indexOf('#'); if (index != -1) { link = link.substring(0, index); } if(!urlmap.testHost(link)) continue; if(!urlmap.testLimit(link)) continue; urls.add(link); } return urls; } //设置主机并建立目录 private void setHost(String host) { this.host=host; this.host_path=root_path+"\\"+host; File host_dir=new File(host_path); if(!host_dir.exists()) host_dir.mkdirs(); } @Override public void run() { if(!root_dir.exists()) root_dir.mkdirs(); while(!Thread.currentThread().isInterrupted() &amp;&amp; !canceled &amp;&amp; (controller.getCount()&lt;controller.gettotal()) )="" {="" try="" {="" 获得一个待抓取的url,如果没有可用url,则进入阻塞状态,该方法调用是线程安全的="" string="" urlstring="urlmap.getURL();" monitorholder.getmonitor().print(id+"开始抓取"+urlstring+"\n");="" 建立url="" url="" url="new" url(urlstring);="" 设置主机="" sethost(url.gethost());="" 清空网页内容,并下贼="" content="null;" download(url);="" 未下载到内容="" if(content="=null)" {="" continue;="" }="" monitorholder.getmonitor().print(id+"抓取"+urlstring+"完毕,进行解析\n");="" setcharset();="" 分析超链接="" list&lt;string=""&gt; urls=retrieveLinks(url); //将分析到的超连接加入到待抓取的URL队列中,并将成功抓取数+1 urlmap.addAll(urls); controller.count(); MonitorHolder.getMonitor().print(id+"解析"+urlstring+"完毕,共计"+urls.size()+"个超链接,开始新任务\n"); content=null; TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { MonitorHolder.getMonitor().print(id+"被中断\n"); canceled=true; } catch (MalformedURLException e) { MonitorHolder.getMonitor().print(id+"报告:URL格式错误\n"); }catch (Exception e) { e.printStackTrace(); } } } //退出,由控制器调用,关闭所有底层I/O资源 public void cancel() { try { if(in!=null) in.close(); } catch (IOException e) { } try { if(out!=null) out.close(); } catch (IOException e) { e.printStackTrace(); } MonitorHolder.getMonitor().print(id+"停止工作\n"); canceled=true; } } </pre> <p> </p> <pre name="code" class="java">package com.wood.core; import java.net.MalformedURLException; import java.net.URL; import java.util.concurrent.*; import java.util.*; public class URLMap { //待抓取的URL队列 private LinkedList&lt;string&gt; URLQueue; //缓存解析出来的URL,使用Hash方便快速查找,&lt;k,false&gt;表示未抓取,&lt;k,true&gt;表示抓取结束 private HashMap&lt;string,boolean&gt; cachedURL; private HashSet&lt;string&gt; hosts; private HashSet&lt;string&gt; format_limit; //默认构造器,初始化队列,集合 private URLMap() { URLQueue=new LinkedList&lt;string&gt;(); cachedURL=new HashMap&lt;string,boolean&gt;(50000); hosts=new HashSet&lt;string&gt;(20); format_limit=new HashSet&lt;string&gt;(20); } public URLMap(List&lt;string&gt; seeds) { this(); for(String s:seeds) cachedURL.put(s, false); URLQueue.addAll(seeds); for (String string : seeds) { try { URL test=new URL(string); String host=test.getHost(); hosts.add(host); } catch (MalformedURLException e) { e.printStackTrace(); } } } public URLMap(String seed) { this(); cachedURL.put(seed, false); URLQueue.add(seed); try { URL test=new URL(seed); hosts.add(test.getHost()); } catch (MalformedURLException e) { e.printStackTrace(); } } //将解析出来的URL添加到URLMap中,如果有重复则忽略,URL有效性由外部保证,该方法是线程安全的 public synchronized void addURL(String url) throws InterruptedException { //如果该URL已存在,忽略该URL if(cachedURL.keySet().contains(url)) return; cachedURL.put(url, false); URLQueue.add(url); //有可用URL,唤醒所有阻塞线程 notifyAll(); } //将解析出来的URL添加到URLMap中,如果有重复则忽略,URL有效性由外部保证,该方法是同步的 public synchronized void addAll(List&lt;string&gt; urls) throws InterruptedException { for (String url : urls) { if(cachedURL.keySet().contains(url)) continue; cachedURL.put(url,false); URLQueue.add(url); } notifyAll(); } //从当前URL队列中获取一个URL,如果当前队列无可用URL,则该线程进入阻塞状态 public synchronized String getURL() throws InterruptedException { //该处进入阻塞 while(URLQueue.size()==0) wait(); //将其从队列中删除 String url=URLQueue.remove(); cachedURL.put(url, true); return url; } public boolean testHost(String host) { for(String host_allow:hosts) { if(host.contains(host_allow)) return true; } return false; } public void addHost(List&lt;string&gt; l) { hosts.addAll(l); } public void addLimit(List&lt;string&gt; l) { format_limit.addAll(l); } public boolean testLimit(String url) { if(format_limit.size()==0) return true; else { for(String s:format_limit) if(url.contains(s)) return true; } return false; } //将待抓取队列打乱 private int swap_check=0; public synchronized void shuffle() { swap_check++; int size=URLQueue.size(); if(size&lt;1000) { java.util.Collections.shuffle(URLQueue); swap_check=0; } else { if(size&gt;=1000 &amp;&amp; size&lt;5000) { if(swap_check==5) { java.util.Collections.shuffle(URLQueue); swap_check=0; } } else { if(swap_check==15) { java.util.Collections.shuffle(URLQueue); swap_check=0; } } } } } </pre> <p><br /><br />附件里是内存使用情况<br /><strong>问题补充</strong><br />主要占用内存的是char[] <br />我的策略是所有分析到的有效URL都存储在HashMap中 <br />但是几万个URL不至于占用大多数内存吧? <br />我的工作线程只有5个,设置的多了,一会就崩了 <br /><br />哪位高人路过,帮我看眼吧 <br />祝你新年好运~</p> <p> </p> <p>附件里是内存占用,缓存的URL总数是20000个,一个大概占用80B,程序内存总数是150MB</p> <p>我不知道到底是什么东西不停的吃内存,回收不掉,程序运行的时间越长,线程数越多,内存吃的越快</p>
【java】该种情况下GC手否能够回收对象?
``` public class A{ public void test(){ for(int i=0;i<2;i++){ List b = new ArrayList(); } } } ``` 请问循环完毕后内存中有几个list对象? 前一个创建的list是否可以被gc回收 主要是想知道对于后一个创建的list,前一个算不算失去了引用
java 内存问题
resin版本3.1 java版本1.5 操作系统版本 centos 4.6 服务器的cpu消耗很低,但内存消耗很快,不到一个小时就吃到交换分区了,把swap分区吃完了,机器就挂掉了。我们配置的时候是Apache和resin结合使用的,apache通过6800端口把jsp传给resin处理。 resin.conf 配置文件里面配置有5个HOST,另外jvm的配置参数是这样的: [code="java"] <jvm-arg>-Xmx2048m</jvm-arg> <jvm-arg>-Xms2048m</jvm-arg> <jvm-arg>-XX:MaxPermSize=128m</jvm-arg> <jvm-arg>-Xmn1200m</jvm-arg> <jvm-arg>-XX:ParallelGCThreads=20</jvm-arg> <jvm-arg>-XX:+UseConcMarkSweepGC</jvm-arg> <jvm-arg>-XX:+UseParNewGC</jvm-arg> <jvm-arg>-Xss1m</jvm-arg> <jvm-arg>-Xdebug</jvm-arg> [/code] top结果: top - 16:47:38 up 1 day, 2:23, 1 user, load average: 5.30, 3.81, 1.82 Tasks: 128 total, 2 running, 126 sleeping, 0 stopped, 0 zombie Cpu(s): 1.2% us, 13.3% sy, 0.0% ni, 71.3% id, 14.1% wa, 0.0% hi, 0.1% si Mem: 8161396k total, 8137632k used, 23764k free, 388k buffers Swap: 8385920k total, 2892784k used, 5493136k free, 8320k cached [b]问题补充:[/b] java进程号8536 [code="java"] top - 21:16:07 up 1 day, 6:51, 2 users, load average: 0.16, 0.17, 0.20 Tasks: 128 total, 1 running, 127 sleeping, 0 stopped, 0 zombie Cpu(s): 1.4% us, 0.1% sy, 0.0% ni, 98.5% id, 0.1% wa, 0.0% hi, 0.0% si Mem: 8161396k total, 7809248k used, 352148k free, 14676k buffers Swap: 8385920k total, 516368k used, 7869552k free, 582428k cached PID USER PR NI %CPU TIME+ %MEM VIRT SWAP RES CODE DATA SHR S COMMAND 8536 root 16 0 11 4:35.74 84.5 8920m 2.1g 6.6g 52 8.5g 36m S java [/code] java进程占用内存87.4%,进程号8536 [code="java"] ps aux root 8536 9.2 87.4 9417572 7136552 ? Sl 20:26 4:43 /usr/local/jdk1.5.0_17/bin/java -Djava.util.logging.manager=com.caucho.log.LogManagerImpl -Djava.system.class.loader=com.caucho.loader [/code] 第二次top: [code="java"] top - 21:20:28 up 1 day, 6:55, 2 users, load average: 0.08, 0.11, 0.16 Tasks: 131 total, 1 running, 130 sleeping, 0 stopped, 0 zombie Cpu(s): 1.2% us, 0.6% sy, 0.0% ni, 97.1% id, 1.1% wa, 0.0% hi, 0.0% si Mem: 8161396k total, 8124104k used, 37292k free, 564k buffers Swap: 8385920k total, 540296k used, 7845624k free, 40192k cached PID USER PR NI %CPU TIME+ %MEM VIRT RES SHR S COMMAND 8536 root 16 0 10 5:08.40 95.8 9.8g 7.5g 28m S java 121 root 16 0 4 35:51.87 0.0 0 0 0 D kswapd0 [/code] 第三次top: [code="java"] top - 21:23:00 up 1 day, 6:58, 2 users, load average: 0.14, 0.16, 0.17 Tasks: 131 total, 1 running, 130 sleeping, 0 stopped, 0 zombie Cpu(s): 1.6% us, 0.2% sy, 0.0% ni, 97.9% id, 0.2% wa, 0.0% hi, 0.0% si Mem: 8161396k total, 8125048k used, 36348k free, 1060k buffers Swap: 8385920k total, 1082024k used, 7303896k free, 38212k cached PID USER PR NI %CPU TIME+ %MEM VIRT SWAP RES CODE DATA SHR S COMMAND 8536 root 16 0 14 5:27.79 97.1 10.5g 2.9g 7.6g 52 10g 28m S java 121 root 15 0 2 35:54.77 0.0 0 0 0 0 0 0 S kswapd0 [/code] 第四次top: [code="java"] Tasks: 131 total, 1 running, 130 sleeping, 0 stopped, 0 zombie Cpu0 : 2.8% us, 0.4% sy, 0.0% ni, 95.7% id, 0.9% wa, 0.0% hi, 0.1% si Cpu1 : 0.6% us, 0.3% sy, 0.0% ni, 98.7% id, 0.4% wa, 0.0% hi, 0.0% si Cpu2 : 0.7% us, 1.2% sy, 0.0% ni, 96.4% id, 1.7% wa, 0.0% hi, 0.0% si Cpu3 : 0.6% us, 0.5% sy, 0.0% ni, 98.3% id, 0.7% wa, 0.0% hi, 0.0% si Cpu4 : 0.5% us, 0.3% sy, 0.0% ni, 98.7% id, 0.4% wa, 0.0% hi, 0.0% si Cpu5 : 0.6% us, 0.3% sy, 0.0% ni, 98.7% id, 0.4% wa, 0.0% hi, 0.0% si Cpu6 : 0.7% us, 0.7% sy, 0.0% ni, 97.7% id, 1.0% wa, 0.0% hi, 0.0% si Cpu7 : 0.5% us, 0.3% sy, 0.0% ni, 98.8% id, 0.4% wa, 0.0% hi, 0.0% si Mem: 8161396k total, 8113456k used, 47940k free, 292k buffers Swap: 8385920k total, 1564668k used, 6821252k free, 32044k cached PID USER PR NI %CPU TIME+ %MEM VIRT RES SHR S COMMAND 8536 root 16 0 9 5:55.63 97.8 11.1g 7.6g 26m S java 121 root 15 0 4 36:12.40 0.0 0 0 0 S kswapd0 [/code] [code="java"] ps aux root 8536 10.0 97.5 11760484 7962748 ? Sl 20:26 5:58 /usr/local/jdk1.5.0_17/bin/java -Djava.util.logging.manager=com.caucho.log.LogManagerImpl -Djava.system.class.loader=com.caucho.loader [/code] 第五次top(swap已经到2G了): [code="java"] top - 21:29:20 up 1 day, 7:04, 2 users, load average: 5.53, 2.84, 1.23 Tasks: 131 total, 2 running, 129 sleeping, 0 stopped, 0 zombie Cpu(s): 1.0% us, 9.8% sy, 0.0% ni, 68.4% id, 20.8% wa, 0.0% hi, 0.0% si Mem: 8161396k total, 8122488k used, 38908k free, 280k buffers Swap: 8385920k total, 2263088k used, 6122832k free, 29776k cached PID USER PR NI %CPU TIME+ %MEM VIRT RES SHR S COMMAND 121 root 16 0 95 37:43.77 0.0 0 0 0 R kswapd0 32161 root 16 0 19 17:29.02 0.1 1079m 5600 3528 S java 8536 root 16 0 19 6:43.04 98.3 11.9g 7.7g 25m S java [/code] [code="java"] ps aux root 8536 10.7 98.3 12598116 8025284 ? Sl 20:26 6:48 /usr/local/jdk1.5.0_17/bin/java -Djava.util.logging.manager=com.caucho.log.LogManagerImpl -Djava.system.class.loader=com.caucho.loader [/code] 检测内存分配: [code="java"] vmstat 5 procs -----------memory---------- ---swap-- -----io---- --system-- ----cpu---- r b swpd free buff cache si so bi bo in cs us sy id wa 1 0 593940 38444 824 40576 26 40 32 43 2 16 1 1 98 1 0 0 622980 43740 824 40672 248 5808 248 5864 1198 1493 2 0 97 1 0 0 649200 41756 852 40756 2166 5308 2190 5347 1274 17118 1 0 94 5 0 0 669316 38108 868 40948 13 4030 13 4064 1187 869 1 0 98 1 0 0 673568 47268 888 40564 13 2203 14 2238 1220 867 1 0 98 1 0 0 679384 40572 908 40192 208 2867 211 2918 1243 924 2 0 97 2 1 0 685080 43964 840 38196 32 4185 32 4220 1286 5405 2 0 97 2 0 0 685280 43068 872 38108 150 3086 174 3128 1502 940 1 0 93 6 0 0 683952 46964 776 36468 814 4018 821 4069 1452 989 1 0 92 6 0 3 685628 46612 808 36516 131 5669 134 5706 1360 940 2 0 92 6 0 1 688560 46428 312 34936 462 2614 471 2658 1372 965 2 4 89 5 0 1 690816 42140 340 33948 399 1882 491 1938 1351 1239 2 1 94 4 0 0 713104 44052 308 33548 906 6016 906 6062 1484 954 1 0 90 8 0 1 745548 36852 496 33684 2371 6489 2406 6524 1312 1132 1 0 93 5 0 0 766192 44924 620 33852 1130 4131 1183 4166 1251 1009 2 0 95 3 0 0 802552 42428 652 34012 638 7272 648 7324 1243 5389 2 0 96 2 vmstat 5 procs -----------memory---------- ---swap-- -----io---- --system-- ----cpu---- r b swpd free buff cache si so bi bo in cs us sy id wa 0 11 2401820 31692 380 31052 27 42 33 45 3 19 1 1 98 1 1 3 2407864 37516 332 29172 3432 2327 3702 2370 1524 1221 1 14 66 20 1 0 2409332 25364 320 29164 4075 1054 4582 1090 1529 1314 1 11 72 16 1 1 2430024 25236 308 29764 3578 4680 4086 4714 1439 1249 1 12 75 12 4 2 2437212 23764 316 30032 4291 2304 4861 2362 1513 1284 1 16 71 12 7 2 2454028 23764 336 29740 5968 4057 6538 4102 1639 1492 1 40 45 14 0 0 2500428 36868 348 30840 4363 9719 4910 9735 1390 71980 0 39 46 14 [/code] [b]问题补充:[/b] @pJun; 两台机器做集群: 1.dell 2950 高配:64位,8G,CPU 8个 2.dell 2950 标配:32位,4G,CPU 8个 两台机器其它配置都一样,跑的程序也相同,但64位的内存泄露相当严重,大概一个小时就会物理内存全部耗光,swap2G全部耗光,需要重启。 32位 没这种情况,偶尔也会有一次,32位物理内存耗到只剩4 50M的时候,就不会用swap了,而是自动重启java服务进程,然后内存就会恢复到启动时候的状态。 64位机器 resin配置文件里最大线程是400, 64位的机器通过jconsole 观察垃圾回收时正常的:在resin配置文件里分配2G内存给jvm,当内存到1.5G的时候,会自动回收) 跟系统环境变量有没有关系,我感觉跟分配的线程有问题?
关于java类生命中周期
1.java类的生命周期,从jvm加载class文件到销毁,什么时候会执行加载, 什么时候会执行销毁操作,使用spring框架与否的区别 2.成员变量的生命周期,定时任务中的一个类,成员变量第一次进入类中某方法 会进行赋值,我知道成员变量与类生命周期是相同的,那么在下一次调用这个 类之前都是空闲状态,会被回收吗 3.关于java JVM管理的内存空间,堆栈,方法区,这些抽象的概念,我目前最重要的 应用就是知道他保存的时长,也就是生命周期,所有成员变量,局部变量,静态,常量 都在什么时间开始有,在什么时候变成无。 3.在网上看到关于JVM GC的文章很晕,希望大神能给小弟用通俗易懂的语言描述下
请教个问题:java进程显示占用了1.4G内存,但在jconsole里怎么才是100M左右?
我用如下代码做一个简单的实验,发现java进程显示占用了1.4G内存,但在jconsole里怎么才是100M左右。 public static void main(String[] args) throws IOException { for (int i = 0; i < 100; i++) { test1(); } System.gc(); Runtime run=Runtime.getRuntime(); //取得当前jvm的运行时实例 run.gc(); //运行Runtime的垃圾回收方法 System.in.read(); } /** * 循环到调用该方法1000次,内存涨到1.4G后不再增长,始终维持这个内存,怎么GC也不降低。 */ private static void test1() { for (int i = 0; i < 1000; i++) { byte[] so = new byte[1000000]; so = null; } } ![图片说明](https://img-ask.csdn.net/upload/201711/17/1510887621_909596.png) 点击jconsole的GC按钮,jconsole里占用内存下降了,但是java进程还是1.4G。 ![图片说明](https://img-ask.csdn.net/upload/201711/17/1510887652_162531.png)
关于直接/非直接字节缓冲区的相关问题
对于ByteBuffer 可以通过allocateDirect()来创建缓冲区。那MappedByteBuffer 他应该也是直接字节缓冲区吧。 问题: 1. 他们两个的区别 2.ByteBuffer .allocateDirect(); 是不是也创建了映射文件。 3.他们在使用的时候创建的是什么内存(物理还是什么),这个内存会不会被GC回收或者被jvm去控制。() ``` static void reserveMemory(long size) { synchronized (Bits.class) { if (!memoryLimitSet && VM.isBooted()) { maxMemory = VM.maxDirectMemory(); memoryLimitSet = true; } if (size <= maxMemory - reservedMemory) {//如果创建直接缓冲区后的内存占用不超过最大内存限制 reservedMemory += size;//更新已分配的内存大小 return; } }    //如果超过最大内存限制,执行垃圾回收 System.gc(); try { Thread.sleep(100);//等待垃圾回收完成 } catch (InterruptedException x) { // Restore interrupt status Thread.currentThread().interrupt(); } synchronized (Bits.class) { if (reservedMemory + size > maxMemory)//如果依然超过最大内存限制,则抛出内存溢出异常 throw new OutOfMemoryError("Direct buffer memory"); reservedMemory += size; } ``` 这个是allocateDirect里调用的方法 他确实是对于内存不够是进行了GC。那MappedByteBuffer呢。 **我说的比较乱 因为我的理解也不是很好见谅**
Java多线程和其创建对象的内存使用机制?
1. ``` public void addActionRecord(Object oldEntity, Object newEntity,String applicationName) { try { ActionVo actionVo = BorpUtil.getActionRecord(oldEntity, newEntity,applicationName); Executors.newFixedThreadPool(1).submit(() -> { try { addAction(actionVo); } catch (Exception var3) { System.out.println(var3.getMessage()); } }); } catch (Exception var4) { System.out.println(var4.getMessage()); } } ``` 主要问题是:是不是每次执行上面这段代码的时候都会创建一个线程?然后用这种线程池创建出的核心线程是不是一直不会被回收?如果这里执行多次的话是不是会创建出许多回收不掉的线程。 PS:addAction(actionVo);这里只是一个业务方法 2.在Linux环境下,每个线程资源共享还是会给每个线程单独分配内存? 3.如果是单独分配内存,当非主线程空闲被回收时,这个线程之前创建的对象会立即被回收吗?还是等垃圾回收的时候才会去回收?
jconsole查看tomcat内存占用曲线
最近在学习java虚拟机的垃圾回收机制,试着用jconsole查看了一下tomcat的内存占用。启动tomcat,发现新生代内存占用曲线如下图: ![图片说明](https://img-ask.csdn.net/upload/201701/11/1484121309_155018.jpg) tomcat没有部署任何应用,自带的manager、hostmanager等也全部删除,tomcat没有处理任何请求,debug模式和非debug模式都是如此,预期稳定后的曲线应该是一条横线,实际情况是波浪线,其中内存占用下降是由于垃圾回收机制起了作用,但是想不明白内存上升的原因,有没有大神能解释一下,谢谢。 运行环境: jdk1.8.0_112 apache-tomcat-8.5.9
怎么能观察出JVM的Old区中存储的都是那些对象
操作系统:Solaris10 JDK:SUN JDK1.5.0_17 [b]问题补充:[/b] jmap这个命令我用了,但我发现只是显示出了实例的数量。看不出来哪些对象是在Old区的。你说用Heap工具分析,是什么Heap工具呢?我用了Optimizeit,也是只能看出实例的数量和引用关系,看不出哪些对象是在Old区的。 [b]问题补充:[/b] 我现在的GC策略是这样的,堆最大,最小都是1024m,young区是512m,对象在from和to之间拷贝5次然后扔到old区。回收算法用的是cms。我们的应用对吞吐量的要求比较高,绝大多数都是短生命周期的对象。我在windows下用optimizeit检查了,不存在内存泄漏,但发现在并发量比较大的时候,有几个对象的实例数量是一直在增长的。但当客户端的程序停止的时候,这些对象又是可以被回收的。我们的程序是运行在solaris上的,由于我没下载到optimizeit的solaris安装文件,或者是类似工具的solaris安装文件,因此不确定,olc区中的那些对象是否就是那几个不断增长的对象。我用jvmstat看了,old区涨的很快。而且程序运行大概20分钟左右就core dump了。有的时候会直接把服务器整死。因此我想看看有没有什么手段来看看old区的对象存储的都是什么来帮我肯定一下,就是那几个对象再搞鬼。 [b]问题补充:[/b] 其实这个问题,在昨天临下班之前的10几分钟突然有了进展。终于排查出,我们的程序是没有内存泄漏的。而是由于传输层的拥挤造成的。设置了socket的readReceiveBuffer和sendBuffer之后这个问题得到了缓解。但是为什么会因为传输层的拥挤导致我们old区的对象很多,这点需要再好好研究一下mina框架。 [b]问题补充:[/b] [quote]根据你的说法, 我觉得你的,配置有问题的, 为什么设计-Xmn512m, 这个是很关键的, 如果你要求很低的world stop. 那么把-Xmn设置到128 或者256m, core dump 的原因可能是因为你CMS机制不起作用, 导致并行收集过多产生的。 另外,也跟你的JAVA的版本有关系。 CMS最好使用JAVA6的版本, 在JAVA5上, 这个技术并不是非常成熟。如果是JAVA5, CMS的启动策略是有BUG的, 这个你可以参考我的BLOG : http://sdh5724.iteye.com/admin/blogs/283977 [/quote] young区默认的大小是堆的1/4,但是对于吞吐量优先的程序,可以设置为堆的1/2。因为对象的生命周期短,应该尽可能的让对象在young区就被回收掉,免得被拷贝到old区,再进行回收时,暂停时间会相对较长。网上有些资料显示了,对于吞吐量优先的程序,应该设置一个较大的young区的说法,Sun的网站上也有,将堆设置为3G,young区设置为2G的例子。你说的CMS最好在JAVA6下用,这个我真的不知道。听说JAVA6的GC机制要比JAVA5好。这个我回去试试。 [quote]readReceiveBuffer和sendBuffer 是操作系统参数, 如果你的OS内存很紧张, 也可能导致系统资源不够。 这个参数应该调整成你业务需要的发送接收的大小, 不可以盲目扩大, 每个TCP连接都会占用这个BUFF的大小。 我建议你一般设置成8K。[/quote] 你说的这个我很关系,对这两个参数我也不太了解,但的确是缓解了问题,而且很明显。目前我们只使用了一个TCP连接。对于你说的“这个参数应该调整成你业务需要的发送接收的大小”,我不太明白是什么意思。主要是我不清楚我们需要的大小是多少啊,呵呵。你说的8K,这个是默认配置。但我们使用这个配置时,程序最多只能跑20分钟,程序就死掉了。这涉及到tcp的传输,因为跟我们对接的另一端,他们是C语言写的,目前他们没有设置缓冲区大小,应该用的也是默认的,但C程序我不太了解,不知道是多少。我把这个缓冲区设置为Integer的最大值了,好像是2G(我也觉得有点儿夸张),程序大概跑了四十分钟,服务器宕机了。 [quote]我觉得, 你是不是因为TCP的连接断开后, 没有释放TCP连接? socket.close(). 会导致大量的time_wait的连接, 你要仔细看下。 OS会在比较长的时间回收[/quote] 我们现在就一个TCP链接,出现问题时,链接没断过。我们应该是没有内存泄漏的,我用Optimizeit检查了好多次了。 很高兴与你讨论这个问题,我感觉现在问题出现在TCP的缓冲区上,应该让C那边也设置一个较大的缓冲区,然后再看看问题能不能得到解决。 [b]问题补充:[/b] 经过几天的测试,总结如下: 1.机器宕机居然是机器的问题,那个机器,不管上面运行的是我们的应用程序还是模拟器,都会宕机。换了其他的几台服务器,都没出现宕机的问题。 2.buffer的设置:我们一个消息的长度是20个字节。每秒钟2000条消息,就是40000个字节,因次buffer设置为40000。但最后还是没有设置这个值采用默认的。因为问题可能不在这里。 3.目前的问题,使用mina的client接收消息时,每秒钟2000条,大概运行一段时间之后,就会mina就会接收到一个很大的包(100K以上)。这导致我们应用层解析这个消息的时候调用层次过多,抛出stackOverFlow的异常,并且主动把连接关闭了。其实,我们可以修改一下我们的代码,避免抛出这个异常。但这不是问题的根源,因为mina传了一个这么大的数据包给应用层就是不正常的。于是我看了一下mina的代码,在read的时候,会根据接收到的消息的长度,来调整allocate的长度。这个上限是receiveByteBuffer的2倍。我尝试修改了mina的代码,让他每次固定allocate 1024个字节。但是问题依然存在,目前没找到解决方法。为了规避这个问题,只是让服务端不给我们发送这个应答,这在业务上是允许的。但没找到问题的根源总是感觉心里堵的荒,打算试试grizzly。
使用java static做缓存 如何定时清理重置static数据
调用外部接口返回数转json加处理需要两分钟,但是数据变化不会太大,现在希望用 缓存存起来,定时重置缓存,使用公司内部缓存工具可以做到设置超时时间如果缓存为空则调用接口且重新为缓存赋值,但缓存失效时总会存在需要直接访问接口而导致访问太慢,所以我想是不是可以用static对数据做内存缓存,思路:用定时任务定时为静态变量重置赋值,但目前遇到如下几个疑问: 1.static变量如何回收,如果我先给变量赋予一个json对象1,再让变量等于另外一个json对象2,之前的对象1 jvm会做什么处理,直接回收掉还是一直留着内存中? 2.有没有其他方式做内存缓存?
爬虫福利二 之 妹子图网MM批量下载
爬虫福利一:27报网MM批量下载    点击 看了本文,相信大家对爬虫一定会产生强烈的兴趣,激励自己去学习爬虫,在这里提前祝:大家学有所成! 目标网站:妹子图网 环境:Python3.x 相关第三方模块:requests、beautifulsoup4 Re:各位在测试时只需要将代码里的变量 path 指定为你当前系统要保存的路径,使用 python xxx.py 或IDE运行即可。
Java学习的正确打开方式
在博主认为,对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章中,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍,博客次之,这又是一个层次了,这里暂时不提后面再谈。博主将为各位入门java保驾护航,各位只管冲鸭!!!上天是公平的,只要不辜负时间,时间自然不会辜负你。 何谓学习?博主所理解的学习,它
大学四年自学走来,这些私藏的实用工具/学习网站我贡献出来了
大学四年,看课本是不可能一直看课本的了,对于学习,特别是自学,善于搜索网上的一些资源来辅助,还是非常有必要的,下面我就把这几年私藏的各种资源,网站贡献出来给你们。主要有:电子书搜索、实用工具、在线视频学习网站、非视频学习网站、软件下载、面试/求职必备网站。 注意:文中提到的所有资源,文末我都给你整理好了,你们只管拿去,如果觉得不错,转发、分享就是最大的支持了。 一、PDF搜索网站推荐 对于大部
linux系列之常用运维命令整理笔录
本博客记录工作中需要的linux运维命令,大学时候开始接触linux,会一些基本操作,可是都没有整理起来,加上是做开发,不做运维,有些命令忘记了,所以现在整理成博客,当然vi,文件操作等就不介绍了,慢慢积累一些其它拓展的命令,博客不定时更新 顺便拉下票,我在参加csdn博客之星竞选,欢迎投票支持,每个QQ或者微信每天都可以投5票,扫二维码即可,http://m234140.nofollow.ax.
比特币原理详解
一、什么是比特币 比特币是一种电子货币,是一种基于密码学的货币,在2008年11月1日由中本聪发表比特币白皮书,文中提出了一种去中心化的电子记账系统,我们平时的电子现金是银行来记账,因为银行的背后是国家信用。去中心化电子记账系统是参与者共同记账。比特币可以防止主权危机、信用风险。其好处不多做赘述,这一层面介绍的文章很多,本文主要从更深层的技术原理角度进行介绍。 二、问题引入  假设现有4个人
程序员接私活怎样防止做完了不给钱?
首先跟大家说明一点,我们做 IT 类的外包开发,是非标品开发,所以很有可能在开发过程中会有这样那样的需求修改,而这种需求修改很容易造成扯皮,进而影响到费用支付,甚至出现做完了项目收不到钱的情况。 那么,怎么保证自己的薪酬安全呢? 我们在开工前,一定要做好一些证据方面的准备(也就是“讨薪”的理论依据),这其中最重要的就是需求文档和验收标准。一定要让需求方提供这两个文档资料作为开发的基础。之后开发
网页实现一个简单的音乐播放器(大佬别看。(⊙﹏⊙))
今天闲着无事,就想写点东西。然后听了下歌,就打算写个播放器。 于是乎用h5 audio的加上js简单的播放器完工了。 欢迎 改进 留言。 演示地点跳到演示地点 html代码如下`&lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;music&lt;/title&gt; &lt;meta charset="utf-8"&gt
Python十大装B语法
Python 是一种代表简单思想的语言,其语法相对简单,很容易上手。不过,如果就此小视 Python 语法的精妙和深邃,那就大错特错了。本文精心筛选了最能展现 Python 语法之精妙的十个知识点,并附上详细的实例代码。如能在实战中融会贯通、灵活使用,必将使代码更为精炼、高效,同时也会极大提升代码B格,使之看上去更老练,读起来更优雅。 1. for - else 什么?不是 if 和 else 才
数据库优化 - SQL优化
前面一篇文章从实例的角度进行数据库优化,通过配置一些参数让数据库性能达到最优。但是一些“不好”的SQL也会导致数据库查询变慢,影响业务流程。本文从SQL角度进行数据库优化,提升SQL运行效率。 判断问题SQL 判断SQL是否有问题时可以通过两个表象进行判断: 系统级别表象 CPU消耗严重 IO等待严重 页面响应时间过长
2019年11月中国大陆编程语言排行榜
2019年11月2日,我统计了某招聘网站,获得有效程序员招聘数据9万条。针对招聘信息,提取编程语言关键字,并统计如下: 编程语言比例 rank pl_ percentage 1 java 33.62% 2 c/c++ 16.42% 3 c_sharp 12.82% 4 javascript 12.31% 5 python 7.93% 6 go 7.25% 7
通俗易懂地给女朋友讲:线程池的内部原理
餐厅的约会 餐盘在灯光的照耀下格外晶莹洁白,女朋友拿起红酒杯轻轻地抿了一小口,对我说:“经常听你说线程池,到底线程池到底是个什么原理?”我楞了一下,心里想女朋友今天是怎么了,怎么突然问出这么专业的问题,但做为一个专业人士在女朋友面前也不能露怯啊,想了一下便说:“我先给你讲讲我前同事老王的故事吧!” 大龄程序员老王 老王是一个已经北漂十多年的程序员,岁数大了,加班加不动了,升迁也无望,于是拿着手里
经典算法(5)杨辉三角
写在前面: 我是 扬帆向海,这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。 这博客是对自己学习的一点点总结及记录,如果您对 Java、算法 感兴趣,可以关注我的动态,我们一起学习。 用知识改变命运,让我们的家人过上更好的生活。 目录一、杨辉三角的介绍二、杨辉三角的算法思想三、代码实现1.第一种写法2.第二种写法 一、杨辉三角的介绍 百度
腾讯算法面试题:64匹马8个跑道需要多少轮才能选出最快的四匹?
昨天,有网友私信我,说去阿里面试,彻底的被打击到了。问了为什么网上大量使用ThreadLocal的源码都会加上private static?他被难住了,因为他从来都没有考虑过这个问题。无独有偶,今天笔者又发现有网友吐槽了一道腾讯的面试题,我们一起来看看。 腾讯算法面试题:64匹马8个跑道需要多少轮才能选出最快的四匹? 在互联网职场论坛,一名程序员发帖求助到。二面腾讯,其中一个算法题:64匹
面试官:你连RESTful都不知道我怎么敢要你?
面试官:了解RESTful吗? 我:听说过。 面试官:那什么是RESTful? 我:就是用起来很规范,挺好的 面试官:是RESTful挺好的,还是自我感觉挺好的 我:都挺好的。 面试官:… 把门关上。 我:… 要干嘛?先关上再说。 面试官:我说出去把门关上。 我:what ?,夺门而去 文章目录01 前言02 RESTful的来源03 RESTful6大原则1. C-S架构2. 无状态3.统一的接
JDK12 Collectors.teeing 你真的需要了解一下
前言在 Java 12 里面有个非常好用但在官方 JEP 没有公布的功能,因为它只是 Collector 中的一个小改动,它的作用是 merge 两个 collector 的结果,这句话
为啥国人偏爱Mybatis,而老外喜欢Hibernate/JPA呢?
关于SQL和ORM的争论,永远都不会终止,我也一直在思考这个问题。昨天又跟群里的小伙伴进行了一番讨论,感触还是有一些,于是就有了今天这篇文。 声明:本文不会下关于Mybatis和JPA两个持久层框架哪个更好这样的结论。只是摆事实,讲道理,所以,请各位看官勿喷。 一、事件起因 关于Mybatis和JPA孰优孰劣的问题,争论已经很多年了。一直也没有结论,毕竟每个人的喜好和习惯是大不相同的。我也看
SQL-小白最佳入门sql查询一
一 说明 如果是初学者,建议去网上寻找安装Mysql的文章安装,以及使用navicat连接数据库,以后的示例基本是使用mysql数据库管理系统; 二 准备前提 需要建立一张学生表,列分别是id,名称,年龄,学生信息;本示例中文章篇幅原因SQL注释略; 建表语句: CREATE TABLE `student` ( `id` int(11) NOT NULL AUTO_INCREMENT, `
项目中的if else太多了,该怎么重构?
介绍 最近跟着公司的大佬开发了一款IM系统,类似QQ和微信哈,就是聊天软件。我们有一部分业务逻辑是这样的 if (msgType = "文本") { // dosomething } else if(msgType = "图片") { // doshomething } else if(msgType = "视频") { // doshomething } else { // dosho
【图解经典算法题】如何用一行代码解决约瑟夫环问题
约瑟夫环问题算是很经典的题了,估计大家都听说过,然后我就在一次笔试中遇到了,下面我就用 3 种方法来详细讲解一下这道题,最后一种方法学了之后保证让你可以让你装逼。 问题描述:编号为 1-N 的 N 个士兵围坐在一起形成一个圆圈,从编号为 1 的士兵开始依次报数(1,2,3…这样依次报),数到 m 的 士兵会被杀死出列,之后的士兵再从 1 开始报数。直到最后剩下一士兵,求这个士兵的编号。 1、方
致 Python 初学者
文章目录1. 前言2. 明确学习目标,不急于求成,不好高骛远3. 在开始学习 Python 之前,你需要做一些准备2.1 Python 的各种发行版2.2 安装 Python2.3 选择一款趁手的开发工具3. 习惯使用IDLE,这是学习python最好的方式4. 严格遵从编码规范5. 代码的运行、调试5. 模块管理5.1 同时安装了py2/py35.2 使用Anaconda,或者通过IDE来安装模
“狗屁不通文章生成器”登顶GitHub热榜,分分钟写出万字形式主义大作
一、垃圾文字生成器介绍 最近在浏览GitHub的时候,发现了这样一个骨骼清奇的雷人项目,而且热度还特别高。 项目中文名:狗屁不通文章生成器 项目英文名:BullshitGenerator 根据作者的介绍,他是偶尔需要一些中文文字用于GUI开发时测试文本渲染,因此开发了这个废话生成器。但由于生成的废话实在是太过富于哲理,所以最近已经被小伙伴们给玩坏了。 他的文风可能是这样的: 你发现,
程序员:我终于知道post和get的区别
IT界知名的程序员曾说:对于那些月薪三万以下,自称IT工程师的码农们,其实我们从来没有把他们归为我们IT工程师的队伍。他们虽然总是以IT工程师自居,但只是他们一厢情愿罢了。 此话一出,不知激起了多少(码农)程序员的愤怒,却又无可奈何,于是码农问程序员。 码农:你知道get和post请求到底有什么区别? 程序员:你看这篇就知道了。 码农:你月薪三万了? 程序员:嗯。 码农:你是怎么做到的? 程序员:
GitHub标星近1万:只需5秒音源,这个网络就能实时“克隆”你的声音
作者 | Google团队译者 | 凯隐编辑 | Jane出品 | AI科技大本营(ID:rgznai100)本文中,Google 团队提出了一种文本语音合成(text to speech)神经系统,能通过少量样本学习到多个不同说话者(speaker)的语音特征,并合成他们的讲话音频。此外,对于训练时网络没有接触过的说话者,也能在不重新训练的情况下,仅通过未知说话者数秒的音频来合成其讲话音频,即网
《程序人生》系列-这个程序员只用了20行代码就拿了冠军
你知道的越多,你不知道的越多 点赞再看,养成习惯GitHub上已经开源https://github.com/JavaFamily,有一线大厂面试点脑图,欢迎Star和完善 前言 这一期不算《吊打面试官》系列的,所有没前言我直接开始。 絮叨 本来应该是没有这期的,看过我上期的小伙伴应该是知道的嘛,双十一比较忙嘛,要值班又要去帮忙拍摄年会的视频素材,还得搞个程序员一天的Vlog,还要写BU
加快推动区块链技术和产业创新发展,2019可信区块链峰会在京召开
      11月8日,由中国信息通信研究院、中国通信标准化协会、中国互联网协会、可信区块链推进计划联合主办,科技行者协办的2019可信区块链峰会将在北京悠唐皇冠假日酒店开幕。   区块链技术被认为是继蒸汽机、电力、互联网之后,下一代颠覆性的核心技术。如果说蒸汽机释放了人类的生产力,电力解决了人类基本的生活需求,互联网彻底改变了信息传递的方式,区块链作为构造信任的技术有重要的价值。   1
程序员把地府后台管理系统做出来了,还有3.0版本!12月7号最新消息:已在开发中有github地址
第一幕:缘起 听说阎王爷要做个生死簿后台管理系统,我们派去了一个程序员…… 996程序员做的梦: 第一场:团队招募 为了应对地府管理危机,阎王打算找“人”开发一套地府后台管理系统,于是就在地府总经办群中发了项目需求。 话说还是中国电信的信号好,地府都是满格,哈哈!!! 经常会有外行朋友问:看某网站做的不错,功能也简单,你帮忙做一下? 而这次,面对这样的需求,这个程序员
网易云6亿用户音乐推荐算法
网易云音乐是音乐爱好者的集聚地,云音乐推荐系统致力于通过 AI 算法的落地,实现用户千人千面的个性化推荐,为用户带来不一样的听歌体验。 本次分享重点介绍 AI 算法在音乐推荐中的应用实践,以及在算法落地过程中遇到的挑战和解决方案。 将从如下两个部分展开: AI 算法在音乐推荐中的应用 音乐场景下的 AI 思考 从 2013 年 4 月正式上线至今,网易云音乐平台持续提供着:乐屏社区、UGC
【技巧总结】位运算装逼指南
位算法的效率有多快我就不说,不信你可以去用 10 亿个数据模拟一下,今天给大家讲一讲位运算的一些经典例子。不过,最重要的不是看懂了这些例子就好,而是要在以后多去运用位运算这些技巧,当然,采用位运算,也是可以装逼的,不信,你往下看。我会从最简单的讲起,一道比一道难度递增,不过居然是讲技巧,那么也不会太难,相信你分分钟看懂。 判断奇偶数 判断一个数是基于还是偶数,相信很多人都做过,一般的做法的代码如下
【管理系统课程设计】美少女手把手教你后台管理
【后台管理系统】URL设计与建模分析+项目源码+运行界面 栏目管理、文章列表、用户管理、角色管理、权限管理模块(文章最后附有源码) 一、这是一个什么系统? 1.1 学习后台管理系统的原因 随着时代的变迁,现如今各大云服务平台横空出世,市面上有许多如学生信息系统、图书阅读系统、停车场管理系统等的管理系统,而本人家里就有人在用烟草销售系统,直接在网上完成挑选、购买与提交收货点,方便又快捷。 试想,
4G EPS 第四代移动通信系统
目录 文章目录目录4G EPSEPS 的架构EPS 的参考模型E-UTRANUEeNodeBEPCMME(移动性控制处理单元)S-GW(E-RAB 无线访问承载接入点)P-GW(PDN 接入点)HSS(用户认证中心)PCRF(计费规则与策略)SPR(用户档案)OCS(在线计费)OFCS(离线计费)接口类型Uu 接口(空中接口,UE 和 AN 之间)S1 接口(AN 和 CN 之间)S1-U 接口和
相关热词 如何提升c#开发能力 矩阵乘法c# c#调用谷歌浏览器 c# 去空格去转义符 c#用户登录窗体代码 c# 流 c# linux 可视化 c# mvc 返回图片 c# 像素空间 c# 日期 最后一天
立即提问