java的学习计划（汇集12篇）_java的学习计划

发表时间：2024-02-15

java的学习计划（汇集12篇）。

java的学习计划 (一)

学习java已经8个月了，在这里跟大家说下心得，我刚开始是看<> 第三版，因为学校没开java课，所以几乎全是自学，用了将近二个月的时间把这本大书啃完，感觉这书不错，但也有很多人说这书不好，的确这书不是按常规的顺序讲的，内容跳跃性强，但讲的很深入，比较适合有cc++基础的人看，这书看完，你就算基本掌握 java的基础了，也就j2se部分。

现在java分三大部分基础，从大到小排列：j2ee， j2se， j2me!

j2ee：这个就是现在最流行，也很java技术用的最多的地方，java企业应用，要学好它，首先就要有java的基础，这是最基本的，然后学习servlet,jsp,javabean以及基本的mvc结构，当然还有其他辅助知识，比如js,html还有一个对数据库的操作，这些都需要时间来学习，学完这些后基本就可以做些简单的web应用程序了，比如模拟一个小的网上银行等等，但做出来后肯定不易维护，因为刚才说的都是技术的性的东西，还需要学些思想性的东西，那就是设计模式，它是对一些解决特定问题的指导，并不是解决问题的方法，现在认可的设计模式一共有23种，在j2ee里除了这23种外还有几种，我还不太了解，我认为设计模式方面的书《设计模式-可复用面向对象软件的基础》英文名《design patterns-elements of reusable object-oriented software》这是提出设计模式那4为大牛写的，此书非常的抽象，使用语言是c++和smalltalk，有勇气和有基础的人可以尝试一下。

j2se：java技术的基础，很多基础都是先从介绍它开始，它和j2ee的区别就是jdk不同，j2ee比j2se的jdk要大一些，多一些类包，但那些是在j2se中用不到的，j2se不光是基础，也是java技术的一个应用方向，就是利用swing开发桌面应用程序，但在windows平台上，m$的地位是无法撼动的，再加上swing开发起来不是很容易，所以在j2se领域上，java一直处于劣势，发展很慢，说到j2se就一定要下eclipse，在别人眼里，eclipse只不过是一个java的ide，但那只是eclipse的冰山一角，其实eclipse是一个大的平台，暂可以把它比喻成windows，我们可以利用winapi去开发在windows上运行的程序，eclipse也可以，我们称为eclipse插件开发，现在这项技术也在慢慢兴起，有些公司已经有应用的项目，eclipse用的是自己开发的gui包，就是swt/jface,其实跟swing是一样的，都是由java写的，但一个是sun写的，一个ibm写的，swt/jface用的本地的资源，所以运行起来很快，界面也可以做的非常漂亮，而且移植也做的很不错，所以eclipse插件可以很容易的移植到linux上，相信这项技术一定很有发展。

java 项目学习总结篇二：

经过这最近一段时间的项目开发与考核，今天终于画上圆满的句号，我长呼了一口气，同时在内心深处，也默默地为接下来的学习，做一个前段时间的项目总结，也是学习的总结，吸取之前的经验教训，前事不忘后事之师，错误并不可怕，可怕的是再在同一个地方犯同样错误，所以对于我来说，更多的去自我认知，知我批评要比表扬和赞许来的'更加深刻，非常有必要做一个总结。

虽然所做的项目并没做到考核老师所希望看到的效果，和得到正面的点评，也与自己所想象的结果大相径庭，当然可能在项目最开始的时候，我也曾做过这样最坏的打算，但是当现实渐渐逼近的时候，我却一时难以接受这样的结果，是我意料之外，但也是情理之中，俗话说：种瓜得瓜，种豆得豆。

在项目开发其中，我有过给自己找借口，有过灰心的时候，也有过急躁，如坐针毡的时候，但是想要作为一个合格优秀的程序员，你不仅不能这样的情绪，而且在真实的开发环境当中，会有遇到比这更艰难的情况，更不好开发环境，所以要完成一个项目的开发，我得要利用好为数不多的学习时间，更加勇敢的直面这些缺点，并且改正它，不要认为自己以前没学过JAVA，没有这方面的经验而去给自己找借口，越过心理上的这一到鸿沟。

考核的胡老师说过：不要总是把自己当成一个学生去看待，这样容易松懈，应该是把自己当做一个职业人去看待，做好当下的每一个效果，上好当下的每一节课，让自己时时刻刻紧张起来。这样类似的话，在我之前的公司，也有主管这样说过，虽然我已大学毕业了，没有完全把自己当一个学生去看待，但自己又何尝不是有过这样的念头，特别是别人都是这样想的时候，学习的态度不够坚定，立场不坚决，这也是导致我没有学好的主要原因之一吧。

工善欲器事，必先利其器。除了保持好的心理和端庄学习的态度外，更要总结更好的学习方法，不要让自己陷入到疲惫学习的死胡同了，积累好的学习经验，去掌握好的学习方法，好的学习方法不仅是自己当下一笔无形的财富，也是在不久的将来，在工作当中竞争的一把利器。

吾日三省吾身，只有在自己的总结中给予自己更多的认知，反思，而少一些褒奖，这样自己会对平时忽视的一些地方，能有更加深刻的理解和认识，实践是检验真理的唯一标准，虽然实践中我们所遇到的挫折与失败会有无数次，而成功只有一次，但是只要成功了，我的付出就是值得的，就像前面有无数个-1，但你只要最总做到了一个 1，你的结果就是 1的，在别人的眼里你就是成功的，在客户的眼里，你项目是物美价廉的。

java的学习计划 (二)

第一阶段：Java语言基础

★ Java语言基础

1、面向对象思维JAVASE

2、（类加载机制与反射，annotation，泛型，网络编程，多线程，IO，异常处理，常用API，面向对象，JAVA编程基础）

3、Java8新特性

第二阶段：数据库

1、Oracle、mysql（SQL语句、SQL语句原理、SQL语句优化、表、视图

2、序列、索引、Oracle数据字典、Oracle 数据库PL/SQL开发

3、数据库设计原则、MySQL 第三阶段：Web基础

★ Web基础

1、HTML5（H5）基本文档结构、链接、列表、表格、表单;

2、CSS 基础语法、盒子模型、浮动布局、定位;

3、JavaScript语言基础、DOM 编程、事件模型等），JQuery，AJAX框架，XML，BootStrap组件

第四阶段：Java Web技术和主流框架

★ Java Web技术和主流框架

1、spring、springMVC、myBatis、Hibeinate

1、JSP&Servlet、maven

2、SpringDatashiroNginx 第五阶段：Linux

★ Linux

1、Linux安装、熟悉Linux的基础命令、vi编辑器的使用、awk和sed命令使用、用户和组

2、文件及目录权限管理、使用ACL进行高级访问控制、网络配置和软件包安装、启动流程和服务管理

3、系统监控和日志管理、进程管理和计划任务、h远程登录、shell基础和shell脚本。

第六阶段：分布式、微服务、大数据技术（Hadoop和Spark）及缓存

★ 大数据技术（Hadoop和Spark）

1、Hadoop （Hadoop基础和环境搭建，HDFS体系结构，MapReduce；Hadoop的集群模式、HDFS联盟，利用ZooKeeper来实现Hadoop集群的HA（高可用性）功能

2、Yarn的任务调度机制，Apache Hive，Pig数据处理，集成Hadoop和Sqoop

3、Flume以及Apache Kafka来实现数据的交换,安装部署HBase,Storm）

4、Scala 语言（Scala环境搭建、Scala基础语法、模式匹配、重载与构造器、Map与reduce、元组、继承、StringContext，Option Some None，Tuple；集合方法和运算，future 对象同步处理和异步处理返回结果）

5、Spark（Spark搭建，Spark-shell 的使用，Spark-submit 提交应用，Spark的内核设计和实现，并对内核中的实现架构、运行原理进行详细的讲解；Spark生态体系中的各个组件，包括：Spark Core，Shark，Spark SQL和Spark Streaming等等）★缓存

1、Redis缓存

2、Memcache缓存 ★微服务

★分布式

第七阶段：项目

★ 项目

1、China-UCSP 项目 SSM(Spring+SpringMVC+MyBatis)

2、用户关系管理系统 S2SH+Maven+Nodejs+MySQL技术实战开发

3、电子商务交易平台 S2SH+Maven+Shiro+Oracle

java的学习计划 (三)

学java不知不觉也已经三年了，从不知java为何物到现在一个小小的j2ee项目经理，虽说不上此道高手，大概也算有点斤两了吧。每次上网，泡bbs逛论坛，没少去java相关的版面，总体感觉初学者多，高手少，精通的更少

由于我国高等教育制度教材陈旧，加上java自身发展不过十年左右的时间。还有一个很重要的原因就是java这门语言更适合商业应用，所以高校里大部分博士老师们对此语言的了解甚至不比本科生多。

在这种环境下，很多人对java感到茫然，不知所措，不懂java能做什么?即便知道了java很有用，也不清楚该从哪里入手，所以就有了java入门难这一说法。

java是一种面向对象语言，真正的面向对象，任何函数和变量都以类(class)封装起来。至于什么是对象什么是类，我就不废话了。

在说java能做什么之前，先说java作为一个真正面向对象语言的优点

这是java和c++最大的不同，java所有的源码以及编译后的文件都以类的形式存在

java没有所谓的类外部定义，所有的函数(方法)以及变量(属性)都必须在类内部定义

这样就不会出现一个类被切割成这里一块那里一块的情况，c++就可以，不是么?

老外看unix界面其实挺顺眼的，他们就是吃unix饭长大的。而unix又是吃百家饭的，不像ms那么唯利是图，所以不怎么对中国人友好。加上我国又没有公司在做操作系统，所以看上去是不怎么顺眼。其实玩过unix的人都知道，unix对中文的支持一直不怎么好

其次第二个，最让人欢呼雀跃的是完全屏蔽了指针，同时引入了垃圾回收机制，任何一个写过c/c++代码的人，都会对内存管理深恶痛绝。因为这使得我们不能把主要精力放在我们关心的事情上，而需要考虑计算机内部的一些事情，作为一个软件工程师，我想没有一个人愿意把大量的时间花在内存管理上，毕竟我们不是电子工程师

此时java的优势体现出来了，它完全屏蔽了内存管理。也就是说，如果你用java写程序，写出来的任何一个程序内存上的开销，都不受你控制。乍一看，似乎你受到了束缚，但实际上不是这样。

因为虽然你的程序无法对内存进行管理，降低了一定的速度，但你的程序会非常非常的安全，因为你无法调用一个空指针，而不像以前写c的时候那样，成天因为空指针而担惊受怕。

当然，如果你深入了解这一行，就会发现java其实也无法保证程序不去调用空的指针，但是它会在最大程度上避免空指针的调用。这已经很好了，安全，这是java的最突出的优点。

第三个，虚拟机跨平台，这是java最大的特点，跨平台。

可能所有人都知道windows，但是不是所有人都知道unix 。和java一样，很多人都不知道unix这种操作系统干什么用。我不想多说unix的应用，这不是主要，但是我要说，大部分小型机、工作站，都跑在unix一族的操作系统上，比如linux/solaris

unix比起windows有一个最显著的特点，稳定，这就好比思科和华为。思科的机器慢但稳定，华为的机器快但不稳定，作为服务器这一端来说，要的評nix在服务器端还是非常有市场的。而且很重要的windows不安全，在ms的宣传中我想所有人都很少看到安全二字。

因为windows操作系统针对的是pc用户，pc死机就死机咯，大不了重启。

windows95最经常冒出来的就是蓝屏，在服务器这一端上因为ms没有自己的芯片。

所以要做系统有些力不从心啊。扯远了，那么java可以做到在windows上编译，然后在unix上运行，这是c/c++做不到的

那么说到这里，java能做什么逐渐清晰起来。

刚才说到了，java程序有一个的特点是安全。这个安全是针对你的系统来说得，系统在跑了java程序之后会特别地稳定。而且还能跨平台，那么很明显，java主要应用于除了windows操作系统以外所有的平台。比如手机，服务器。想想看，如果你写的程序要跑在手机上，而手机有多少款用的是windows?

就算有，那如果你用c/c++，是不是要针对每一款手机写一套程序呢?

累死，那跨平台的java就不用，做到编译一次，随时运行。同样，在服务器这一端，如果我想给一个网络门户站点，比如sina 。

写一个应用程序，pc的性能肯定无法满足sina这样大站点并发数量的要求。那么它就需要买服务器，那么服务器ms没有市场，而且windows很不安全。那么十之八九会买一个sun/ibm的机器，或者hp，但不管是谁的机器

它装的操作系统也不会是windows，因为windows太不安全了，而且多核的支持太差了。

程序内存上的开销，都不受你控制。乍一看，似乎你受到了束缚，但实际上不是这样。因为虽然你的程序无法对内存进行管理，降低了一定的速度，但你的程序会非常非常的安全，因为你无法调用一个空指针，而不像以前写c的时候那样，成天因为空指针而担惊受怕。

当然，如果你深入了解这一行，就会发现java其实也无法保证程序不去调用空的指针，但是它会在最大程度上避免空指针的调用。这已经很好了，安全，这是java的最突出的优点

unix比起windows有一个最显著的特点，稳定，这就好比思科和华为。思科的机器慢但稳定，华为的机器快但不稳定，作为服务器这一端来说，要的皇怯卸嗫欤俏榷ǎ??評nix在服务器端还是非常有市场的。而且很重要的windows不安全，在ms的宣传中我想所有人都很少看到安全二字。

因为windows操作系统针对的是pc用户，pc死机就死机咯，大不了重启。

windows95最经常冒出来的就是蓝屏，在服务器这一端上因为ms没有自己的芯片。

所以要做系统有些力不从心啊。扯远了，那么java可以做到在windows上编译，然后在unix上运行，这是c/c++做不到的

就算有，那如果你用c/c++，是不是要针对每一款手机写一套程序呢?

累死，那跨平台的java就不用，做到编译一次，随时运行。同样，在服务器这一端，如果我想给一个网络门户站点，比如sina 。

它装的操作系统也不会是windows，因为windows太不安全了，而且多核的支持太差了。

java的学习计划 (四)

学习Java的计划

Java作为一种常用的编程语言，拥有广泛的应用领域，包括软件开发、移动应用程序开发、Web应用程序开发等。因此，学习Java对于想要进入编程领域的人来说是非常重要的。在下面的文章中，我将详细阐述学习Java的计划，以便能够帮助初学者更好地掌握这门语言。

为了学习Java，我们需要一个良好的学习环境。在计划中，我会安装并配置Java的开发环境。对于初学者来说，我建议使用Eclipse或者IntelliJ IDEA这样的IDE工具。这些工具提供了丰富的功能，如代码自动补全、错误检查等，可以大大提高学习效率。

我们需要一个系统化的学习材料。在计划中，我会选择一本权威且易于理解的Java教材作为主要的学习资料。这本教材应该包含Java的基本概念、语法规则以及常见的编程实践。同时，我会搜索一些在线教程和视频资源，以便更全面地了解Java的特性和应用场景。

在学习Java的过程中，理论知识的学习是非常重要的，但实践是掌握Java编程的关键。因此，在计划中，我会编写一些简单的程序，并通过调试和修改来加深对Java的理解。同时，我会积极参与一些开源项目和编程实践，以便更好地应用所学知识并加强编程技巧。

为了更好地学习Java，我计划组建一个学习小组。在小组中，我们可以相互学习、交流经验，并共同完成一些编程挑战。通过合作学习，我们不仅可以互相帮助解决问题，还可以在解决问题的过程中提高自己的编程能力。

除了以上的主要计划，我还有一些额外的学习措施。比如，我会经常参加相关的技术讲座和研讨会，以了解最新的Java开发趋势和技术进展。我还会定期阅读一些相关的博客和论坛，以了解其他人的经验和观点。同时，我会关注一些Java社区和在线学习平台，以便与其他Java程序员互动交流，并深入了解Java的最新动态。

学习Java是一个长期而持续的过程，需要不断地实践和学习。通过制定详细的学习计划，并积极参与实践和交流，我们可以更好地掌握Java编程，提高自己的技术水平。希望这篇文章能对想要学习Java的初学者有所帮助。

java的学习计划 (五)

本节介绍如何应用Dreamweaver MX 2004创建自己的网页。

从头创建自己的页面，可以使用 Dreamweaver MX 2004起始页创建新页，或者可以选择“文件” >“新建”，弹出如下对话框：

从各种预先设计的页面布局中选择一种。比如：选择“基本页”HTML，点击创建按钮。Dreamweaver MX 2004即展开工作区界面(一个空白页)：

您可以在这个空白页添加表格和输入文本进行编辑。如果您要向页面添加图片或其它元素，应先保存这个空白页。选择“文件”>“另存为”，在“另存为”对话框中，浏览到站点本地根文件夹下。填入文件名，保存退出。

我们已经描绘了小屋的蓝图，从现在开始，为我们的小屋添砖加瓦吧。打开01.html，制作一个图文混排的简单页面。

头内容再浏览器中是不可见的，但是却携带着网页的重要信息，如关键字、描述文字等，还可以实现一些非常重要的功能，如自动刷新功能。

鼠标左键单击插入工具栏最左边按钮旁的下拉小三角，在弹出菜单中选择“HTML”项，出现“文件头”按钮，点开下拉菜单，就可以进行头内容的设置了。

设置标题，网页标题可以是中文、英文或符号，显示在浏览器的标题栏中。我们直接在设计窗口上方的标题栏内输入或更改，就可以完成网页标题的编辑了。

插入关键字，关键字用来协助网络上的搜索引擎寻找网页。要想让更多的人看见你的网站，这项要好好填哦^_^单击上图所示的“关键字”项，弹出“关键字”对话框，填入关键字即可。

插入META，META标记用于记录当前网页的相关信息，如编码，作者，版权等，也可以用来给服务器提供信息。单击上图所示的“META”项，弹出“META”对话框，在“属性”栏选择“名称”属性，在“值”文本框中输入相应的值，可以定义相应的信息。

单击“属性栏”中的“页面属性”按钮，打开的“页面属性”对话框。

设置外观，“外观”是设置页面的一些基本属性。我们可以定义页面中的默认文本字体、文本字号、文本颜色、背景颜色和背景图像等。我们设置页面的所有边距为0。

设置链接，“链接”选项内是一些与页面的链接效果有关的设置。“链接颜色”定义超链接文本默认状态下的字体颜色，“变换图像链接”定义鼠标放在链接上时文本的颜色，“已访问链接”定义访问过的链接的颜色，“活动链接”定义活动链接的颜色。“下划线样式”可以定义链接的下划线样式。

设置标题，“标题”用来设置标题字体的一些属性。如下图所示，在左侧“分类”列表中选择“标题”，这里的标题指的并不是页面的标题内容，而是可以应用在具体文章中各级不同标题上的一种标题字体样式。我们可以定义“标题字体”及6种预定义的标题字体样式，包括粗体、斜体、大小和颜色。按自己的喜欢的风格设置吧。

dreamweaver入门(2004版本):超级链接：

作为网站肯定有很多的页面，如果页面之间彼此是独立的，那么网页就好比是孤岛，这样的网站是无法运行的。为了建立起网页之间的联系我们必须使用超级链接。称“超级链接”，是因为它什么都能链接，如：网页、下载文件、网站地址、邮件地址……等等。下边我们就来讨论怎样在网页中创建超级链接。

在网页中，单击了某些图片、有下划线或有明示链接的文字就会跳转到相应的网页中去。

1、在网页中选中要做超级链接的文字或者图片。

2、在属性面板中单击黄色文件夹图标，在弹出的对话框里选中相应的网页文件就完成了。做好超级链接属性面板出现链接文件显示。(如下图)

3、按F12预览网页。在浏览器里光标移到超级链接的地方就会变成手型。

〖提示〗你也可以手工在链接输入框中输入地址。给图片加上超级链接的方法和文字完全相同。

如果超级链接指向的不是一个网页文件。而是其他文件例如zip、exe文件等等，单击链接的时候就会下载文件。

超级链接也可以直接指向地址而不是一个文件，那么单击链接直接跳转到相应的地址。例如，在链接框里写上那么，单击链接就可以跳转到读书屋网站。

在网页制作中，还经常看到这样的一些超级链接。单击了以后，会弹出邮件发送程序，联系人的地址也已经填写好了。这也是一种超级链接。制作方法是：在编辑状态下，先选定要链接的图片或文字(比如：欢迎您来信赐教!)，在插入栏点或点插入菜单选“电子邮件链接”弹出如下对话框，填入E-Mail地址即可。

提示：还可以选中图片或者文字，直接在属性面板链接框中填写“mailto：邮件地址”。(如下图)

创建完成后，保存页面，按F12预览网页效果。

注意，我们这里所说的图片上的超级链接是指在一张图片上实现多个局部区域指向不同的网页链接。比如一张中国地图的图片，单击了不同的省跳转到不同的网页。可点的区域就是热区。为了演示制作效果下面的中国地图我加了一些链接，你可以用鼠标测试。鼠标移动到省份的热区，会显示提示，如果有预先设置的网站，点击会进入对方的网站。

1、首先插入图片。单击图片，用展开的属性面板上的绘图工具在画面上绘制热区。

2、属性面板改换为热点面板如图：链接输入框：填入相应的链接。替代框：填入你的提示文字说明。目标框：不作选择则默认在新浏览器窗口打开。

3、保存页面，按F12预览，用鼠标在设置的热区检验效果。

提示：对于复杂的热区图形我们可以直接选择多边形工具来进行描画。替代框填写了说明文字以后，光标移上热区就会显示出相应的说明文字。

超级链接属性面板中的目标选项。

“目标”我们称它为目标区。也就是超级链接指向的页面出现在什么目标区域。默认的情况下域中总有四个选项。

④_top：跳出所有框架，页面直接出现在浏览器中。

【小结】本节教程主要探讨创建页面的链接。

dreamweaver入门(2004版本):表格设计：

表格是现代网页制作的一个重要组成部分。表格之所以重要是因为表格可以实现网页的精确排版和定位。本节教程我们分为两步来进行。首先看表格操作的一个实例。然后来看一些表格操作的基本方法。在开始制作表格之前，我们首先对表格的各部分的名称做一个介绍。

一张表格横向叫行，纵向叫列。行列交叉部分就叫做单元格。

单元格中的内容和边框之间的距离叫边距。单元格和单元格之间的距离叫间距。整张表格的边缘叫做边框。

这幅页面的排版格式，如果用以前我们所讲的对齐方式是无法实现的。因此我们需要用到表格来做。实际上是用两行两列的表格来制作。

1、在插入栏中选择按钮或“插入”菜单>选“表格”。系统弹出表格对话框。这些参数我们都已经认识了。行：2。列：2。其余的参数都保留其默认值。。

2、在编辑视图界面中生成了一个表格。表格右、下及右下角的黑色点是调整表格的高和宽的调整柄。当光标移到点上就可以分别调整表格的高和宽。移到表格的边框线上也可以调整。

3、在表格的第一格按住左键不放，向下拖拽选中二格单元格。

然后在展开的属性面板中选择合并单元格按钮。将表格的单元格合并。如果要分割单元格，则可以用合并单元格按钮右边的按钮。

4、用鼠标拖拽表格的边框调整到适当的大小。

5、单击左边的单元格，然后输入“摄影作品赏析”文字，并调整大小，因是竖排应每个字回车一次。如果需要调整格子的大小。只需要鼠标的光标移动到边框上拖拽即可。

6、在右边上下单元格内分别插入图片和文本。页面的基本样子有了。

7、光标移动到表格的边框上单击。表格周围出现调整框，表示选中整张表格。然后，在属性面板中将“边框”值设置适合的值，如果为0，边框在编辑状态，为虚线显示，浏览时就看不见了。

一个符合要求的页面在表格的帮助下做好了。

通过上面的操作我们对于表格有了一个初步的认识。还要提示一点，对整幅表格操作和对一个单元格操作的时候，相应的属性面板是不同的。

表格颜色设置，选择整幅表格后，利用属性面板的颜色选择器设置背景色。单元格也可单独设置。鼠标在需要设置的单元格点一下，其余操作同上。

下面我们就来看看这些属性面板的区别。

表格的属性面板，要出现这个面板必须先选中整幅表格，方法上面已经提到过了。您可以在众多选项中填入需要的参数。

选中了单元格之后属性面板就发生如下变化了。选择行或者列都属于选中单元格。

对表格操作的几种常用方式：

表格还可以增加或者删除行或者列。在一个单元格中单击鼠标右键。在右键菜单中选择表格选项>>选择“插入行或列”。系统会弹出对话框如下。

在对话框里填入数据即可。最后要说的是选中表格中的各种元素的方法：

选中一行，把光标移到该行的最左边单元格的左面，光标会变成箭头状。单击就可以选中一行。

选中一列，把光标移到该列的最上边单元格的上面，光标会变成箭头状，然后单击可以选中一列。

选中整张表格，把光标移到表格的左上角或右边框或下边框线上。单击即可选中整幅表格。选中的表格会在周围出现一个黑框表示整张表格选中了。

选中单元格。单元格可以同时选中多个。选择连续的单元格，光标先选中的一个单元格，按shift键不放，选取最后一个单元格。选不连续的单元格。按住Ctrl键，点取所需要的单元格即可。

我们对于表格的使用就讲到这里，表格是网页制作的基本技术，只有通过不断实践才能充分掌握。

dreamweaver入门(2004版本):框架技术：

在浏览网页的时候，我们常常会遇到这样的一种导航结构。就是超级连接做在左边单击以后链接的目标出现在右面。或者在上边单击链接指向的目标页面出现在下面。要做出这样的效果，必须使用框架。为了更好的理解什么是框架。我们画一张示意图来进行讨论。

这是一个左右结构的框架。事实上这样的一个结构是由三个网页文件组成的。首先外部的框架是一个文件，图中我们用index.htm命名。框架中左边命名为A，指向的是一个网页A.htm。右边命名为B，指向的是一个网页B.htm。

1、点“文件”菜单>新建，弹出“新建文档”

Dreamweaver MX 2004生成一个空白的框架页面，

2、选择「窗口」菜单>“框架”，弹出“框架”面板。从框架面板可知，系统对左右框架生成命名。左框架名为：leftFrame，右框架名为：mainFrame，当然您可以通过框架属性面板对框架重新命名，了解这一点非常重要。创建超级链接时，要依据它正确控制指向的页面。

3、保存框架。选择“文件”菜单点击“保存全部”。系统弹出对话框。这时，保存的是一个框架结构文件。我们按照惯例都命名为index.htm。

保存的时候如果虚线框笼罩的是周围一圈就是保存框架结构。

虚线笼罩在右边就是保存框架中右边网页。

4、下面我们要实现按左边的超级链接，对应的页面出现在右边。在左边的页面中做上超级链接。指向一个已经存在的页面。注意做好链接以后，要在目标栏中设置为mainFrame。

6、设置完毕，保存全部，按F12预览网页。链接指向的页面出现在右边框架中。

7、重复以上步骤，把左框架所有的链接做完，一个简单的网站导航结构创建完成。

框架有很多优点，但是若理解不很透彻，容易搞混。如果您的网站页面不多，可以创建一个不使用框架的Web页面来完成框架的功能。例如，如果您想让导航条显示在页面的左侧或顶部，既可以使用框架页面，也可以在每一页包含该导航条而不使用框架。

java的学习计划 (六)

学习java已经8个月了，在这里跟大家说下心得，我刚开始是看第三版，因为学校没开java课，所以几乎全是自学，用了将近二个月的时间把这本大书啃完，感觉这书不错，但也有很多人说这书不好，的确这书不是按常规的顺序讲的，内容跳跃性强，但讲的很深入，比较适合有cc++基础的人看，这书看完，你就算基本掌握 java的基础了，也就j2se部分。

现在java分三大部分基础，从大到小排列：j2ee， j2se， j2me!

java的学习计划 (七)

包括jre运行环境和jvm虚拟机，在oricle官网下载javaSE版本JDK包;配置好环境变量就可以使用了。

1.基本数据类型整形，字符型，字节型，长整形，短整形，浮点型，双精度，布尔型;

2.运算符+，-，*，/，%等;

3.控制流(while,switch，if else);

4.数组的定义方式。

此阶段基本无难度，只要了解练习例题。

1.类和对象;

2.java语言三大特性，封装、继承、多态;

3.一些关键字学习(static，final，abstract,extends)等。

这是重点，大家根据知识点一步步研究学习才是关键。

例如：文件IO，集合(类似C语言数据结构)，异常处理，线程，网络，JDBC数据库操作等，都是掌握面向对象以后，在查找不同的类使用类中不同的方法达到应用的效果，所以并不会很难。等基础语法掌握了就可以继续后面框架学习(java web方向，android学习)，相信明确思路你会豁然开朗，更有学习动力。

java的学习计划 (八)

原创： 17软工5班刘雨晴

在java的海洋中遨游一年的时间，从面向对象的思想到IO流到网络编程，我不断的接触到java基础知识，在学习过程中不断进步，不断成长。作为一名软件工程的学生，学习java是我学习的重中之重，在长达一年的学习过程中，我也对java也有新的认识。在学习java时，会问问自己为什么要学习java？在当今时代，Java仍然是世界上最受欢迎的编程语言之一，有无限多种方法使用Java。据2016年数据显示，Java被评为最受欢迎的编程语言之一；最新的一些报告证明，Java程序员是业内薪资最高的程序员之一。根据全球数字化业务媒体机构的分析，拥有Java技能有利于升值加薪；同时，java是零基础的和基础薄弱的学员可以很容易的接受的一种语言。我在漫长的学习java的岁月中，遇到了许多大大小小的困难。首先，在学习java开始中，老师往往会布置很多代码题进行实操或者书写在作业本上。在刚刚开始的几次作业中，我往往因为自己的浮躁与不耐烦，直接向同学要他们的代码把作业上交，但渐渐的发现，课堂跟不上，成绩不佳，我陷入了迷惘中……后来，意识到自己学习java的态度与方式是不对的，经过调整，也有了自己的一份学习java的心得体会。 java的学习基础——C语言，意识到在课上听不懂的原因也来自于自己在大一上学期并没有把C语言学习透彻，所以我会利用课后的时间看网上的视频来让自己的C语言基础提高。 java的学习需要理解代码的思路。在写代码与学习java知识点时，往往对于每句代码都应该理解透彻，在以后的代码书写中，自己才能写出正确的代码，甚至于找出自己的代码错误。这对于代码的理解透彻，就需要自己在上课时，好好理解老师的代码思维，自己也需要多看看关于代码的书，加深理解。 java的学习需要保持良好的心态。在进行代码实操时，自己写出大量的代码却运行不出结果。这时，自己并不能因为不耐烦与困难的打击就直接放弃，而是要进行学习，通过自纠，问同学，找课外知识来解决问题。同时，在学习java的漫漫长路中，坚持是十分重要的。在坚持中，找寻学习的方式，让自己进步与成长。 java的学习需要多做，多思考。在java学习中，不仅要学会打课内的代码，也需要通过百度找寻课外的代码，举一反三，自己解决很多的问题。在这一年的学习中，我对于java有了初步的认识与了解，我知道自己真正掌握java还需要一段时间的学习，但我相信我自己只要有颗想学习好java的心，对于以后的困难是不惧怕的，我相信在学习java中，自己是在此过程中不断成长的，进步的。

java的学习计划 (九)

1. 学习之路，不走弯路，就是捷径

软件开发之路是充满荆棘与挑战之路,也是充满希望之路。Java学习也是如此，没有捷径可走。所有的人都期盼成功，但是并不是每个人都会为走向成功全力以赴。人们在渴望成功的同时，也渴望能够少一分努力，多一分收获。而事实上要获取真正的成功，每个人都必须经历艰辛。无论你出身豪门，还是出身寒舍，你都不得不接受这样一个事实:成功没有捷径可走，只有顽强的意志与坚持不懈的奋斗才能带你走向成功。

2. 如何学习程序设计?

Java是一种平台，也是一种程序设计语言.首先一定要保持热情，买一本关于这种语言入门的书，一开始不要看太难的，循序渐进，先看一遍。多练基础代码，将各种语句练得非常熟练，可以选一些计算机语言初等练习题做做。再重头到尾好好看一遍，哪里不懂，可以与他人交流。多看看别人用这种语言写的程序，借鉴编程方法，对自己错误的思想进行校正。多多练习，每天都打一些代码，毕竟熟能生巧!

3. 培养兴趣

兴趣是指一个人力求认识某种事物或从事某种活动的心理倾向。知识是兴趣产生的基础条件，因而要培养某种兴趣，就应有某种知识的积累，学习编程，就应该多看看那方面的书籍，不仅能提高自己的文化内涵，也能渐渐培养自己的学习热情。有空多到一些程序员论坛转转，你会发现，他们其实很乐观幽默，时不时会冒出智慧的火花。

4. 脚踏实地,循序渐进

现实生活中，人人都有梦想，都渴望成功，都想找到一条成功的捷径。其实，捷径就在你的身边，那就是勤于积累，脚踏实地，积极肯干。无论做什么事都要戒骄戒躁，踏实地走好每一步，让自己的生活有目标、有计划，这样我们的生活才会变得充实，我们离成功也就越来越近了;相反，如果浮躁、急功近利，就不能集中精力去完成自己的人生目标，最后很可能一事无成，一败涂地。

5. 多实践,快实践

纸上得来终觉浅,绝知此事要躬行. 软件开发是一门工程学科，注重的就是实践，"君子动口不动手"对软件开发人员来讲根本就是错误的，他们提倡"动手至上"，但别害怕，他们大多温文尔雅，没有暴力倾向，虽然有时候蓬头垢面的一副"比尔盖茨"样。有前辈高人认为，学习编程的秘诀是：编程、编程、再编程，笔者深表赞同。不仅要多实践，而且要快实践。我们在看书的时候，不要等到你完全理解了才动手敲代码，而是应该在看书的同时敲代码，程序运行的各种情况可以让你更快更牢固的掌握知识点

6. 多读好书

书中自有黄金屋，书中自有颜如玉。培根说，“读史使人明智，读诗使人聪慧，演算使人精密，哲理使人深刻，伦理学使人有修养，逻辑修辞使人善辨。” 从书中可以领悟“不以物喜，不以己悲”豁达情怀，亦可以领略“天下兴亡，匹夫有责”的豪迈心胸。从好书中提升了思想境界，陶冶了情操。

7. 思想的领悟

学习Java也是如此，必须要有扎实的基础，你才能在J2EE、J2ME领域游刃有余。掌握了基础语法和Java程序运行原理后，我们就可以用 Java语言实现面向对象的思想了。面向对象，是一种方法学;是独立于语言之外的编程思想;是CBD基于组件开发的基础;属于强势技术之一。

java的学习计划 (十)

1、重视基础学习

在参加苏州java培训学校的过程中，大家一定要注意学习java打牢基础很关键。俗话说“勿在浮沙筑高台”，打不好基础怎么能建起知识的高楼呢?更别提进一步拓展了。所以在前期的基础教学过程中，大家要脚踏实地，尤其是零基础学员，不能浮躁，一点点掌握并做好知识巩固很重要。

2、做好日常积累

参加java培训班，学得好的同学通常都是比较细致、注意小节的。除了在上课期间认真学习听课，在休息时间，他们也会抓住短暂的时间来巩固所学的知识点，看看书，并做一些练习题，在这样一点一滴日常的积累中往往能得到意外的收获。正所谓“不积跬步，无以至千里;不积小流，无以成江海”说的就是这个道理。学习的差异不是体现在课堂上，而是在课堂下，高手就是这样慢慢练出来的。

3、保持谦逊态度

参加java培训的学员，有些是有一定java基础的，起初比零基础学员懂得多一些，培训期间就容易变得自大，但常言道“闻道有先后，术业有专攻”，不能因此而沾沾自喜，目中无人。一旦踏入社会，就会发现java技术牛人比比皆是，只有谦虚谨慎，踏实学习，掌握技术才最重要。

以上是学习java技术比较重要的三个方面，这些学习的方法和技巧也是苏州java培训学校的老师多番强调的，但是很多人都没有当回事。小编提醒大家，这些看似细节的方面往往就是决定成败的关键。

java的学习计划 (十一)

Java 语言的Calendar(日历),Date(日期)，和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分，日期是商业逻辑计算一个关键的部分。所有的开发者都应该能够计算未来的日期，定制日期的显示格式，并将文本数据解析成日期对象。创建一个日期

Java 语言的Calendar(日历),Date(日期)，和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分。日期是商业逻辑计算一个关键的部分。所有的开发者都应该能够计算未来的日期，定制日期的显示格式，并将文本数据解析成日期对象。

让我们看一个使用系统的当前日期和时间创建一个日期对象并返回一个长整数。这个时间通常被称为Java 虚拟机(JVM)主机环境的系统时间。

importjava.util.Date;

public class DateExample1 {

public static void main(String[] args) {

Date date = new Date;

System.out.println(date.getTime());

} }

在星期六，9月29日，下午大约是6:50的样子，上面的例子在系统输出设备上显示的结果是 1001803809710。值得注意的是我们使用了Date 构造函数创建一个日期对象，这个构造函数没有接受任何参数，而这个构造函数在内部使用了System.currentTimeMillis() 方法来从系统获取日期。现在我们已经知道了如何获取从1970年1月1日开始经历的毫秒数了。我们如何才能以一种用户明白的格式来显示这个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基类 java.text.DateFormat 就派得上用场了。

假如我们希望定制日期数据的格式，比方星期六-9月-29日-20. 下面的例子展示了如何完成这个工作:

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateExample2 {

public static void main(String[] args) {

SimpleDateFormat bartDateFormat = new SimpleDateFormat(“EEEE-MMMM-dd-yyyy”);

Date date = new Date();

System.out.println(bartDateFormat.format(date));

} }

只要通过向SimpleDateFormat 的构造函数传递格式字符串“EEE-MMMM-dd-yyyy”，我们就能够指明自己想要的格式。格式字符串中的ASCII 字符告诉格式化函数下面显示日期数据的哪一个部分。EEEE是星期，MMMM是月，dd是日，yyyy是年。字符的个数决定了日期是如何格式化的。传递“EE-MM-dd-yy”会显示 Sat-09-29-01。

假设我们有一个文本字符串包含了一个格式化了的日期对象，我们希望解析这个字符串并从文本日期数据创建一个日期对象。我们将再次以格式化字符串“MM-dd-yyyy” 调用SimpleDateFormat类。但是这一次，我们使用格式化解析而不是生成一个文本日期数据。我们的例子，显示在下面，将解析文本字符串“9-29-”并创建一个值为001736000000 的日期对象。

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateExample3 {

public static void main(String[] args) {

// Create a date formatter that can parse dates of

// the form. MM-dd-yyyy.

SimpleDateFormat bartDateFormat = new SimpleDateFormat(“MM-dd-yyyy”);

// Create a string containing a text date to be parsed.

String dateStringToParse = “9-29-2001”;

try {

// Parse the text version of the date.

// We have to perform. the parse method in a

// try-catch construct in case dateStringToParse

// does not contain a date in the format we are expecting.

Date date = bartDateFormat.parse(dateStringToParse);

// Now send the parsed date as a long value

// to the system output.

System.out.println(date.getTime());

}

catch (Exception ex) {

System.out.println(ex.getMessage());

既然我们已经可以生成和解析定制的日期格式了，让我们来看一看如何使用内建的格式化过程。方法 DateFormat.getDateTimeInstance() 让我们得以用几种不同的方法获得标准的日期格式化过程。下面是我们获取了四个内建的日期格式化过程。它们包括一个短的，中等的，长的，和完整的日期格式。

import java.text.DateFormat;

import java.util.Date;

public class DateExample4 {

public static void main(String[] args) {

Date date = new Date();

DateFormat shortDateFormat = DateFormat.getDateTimeInstance(

DateFormat.SHORT, DateFormat.SHORT);

DateFormat mediumDateFormat = DateFormat.getDateTimeInstance(

DateFormat.MEDIUM, DateFormat.MEDIUM);

DateFormat longDateFormat = DateFormat.getDateTimeInstance(

DateFormat.LONG, DateFormat.LONG);

DateFormat fullDateFormat = DateFormat.getDateTimeInstance(

DateFormat.FULL, DateFormat.FULL);

System.out.println(shortDateFormat.format(date));

System.out.println(mediumDateFormat.format(date));

System.out.println(longDateFormat.format(date));

System.out.println(fullDateFormat.format(date));

}

注意我们在对 getDateTimeInstance的每次调用中都传递了两个值：第一个参数是日期风格，而第二个参数是时间风格，

它们都是基本数据类型int(整型)。考虑到可读性，我们使用了DateFormat 类提供的常量: SHORT，MEDIUM，LONG，和 FULL。

运行我们的例子程序的时候，它将向标准输出设备输出下面的内容:

Saturday，September 29，2001 8:44:45 PM EDT

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。

假设你想要设置，获取，和操纵一个日期对象的各个部分，比方一个月的一天或者是一个星期的一天，为了演示这个过程，我们将使用具体的子类 java.util.GregorianCalendar。考虑下面的例子，它计算得到下面的第十个星期五是13号。

import java.util.GregorianCalendar;

import java.util.Date;

import java.text.DateFormat;

public class DateExample5 {

public static void main(String[] args) {

DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL);

// Create our Gregorian Calendar.

GregorianCalendar cal = new GregorianCalendar();

// Set the date and time of our calendar

// to the system´s date and time

cal.setTime(new Date());

System.out.println(“System Date: ” + dateFormat.format(cal.getTime()));

// Set the day of week to FRIDAY

cal.set(GregorianCalendar.DAY_OF_WEEK, GregorianCalendar.FRIDAY);

System.out.println(“After Setting Day of Week to Friday: ” +dateFormat.format(cal.getTime()));

int friday13Counter = 0;

while (friday13Counter<= 10) {

// Go to the next Friday by adding 7 days.

cal.add(GregorianCalendar.DAY_OF_MONTH，7);

// If the day of month is 13 we have

// another Friday the 13th.

if (cal.get(GregorianCalendar.DAY_OF_MONTH) == 13) { friday13Counter++;

System.out.println(dateFormat.format(cal.getTime()));

}

在这个例子中我们作了有趣的函数调用:

cal.set(GregorianCalendar.DAY_OF_WEEK,

GregorianCalendar.FRIDAY);

和:cal.add(GregorianCalendar.DAY_OF_MONTH，7);

set 方法能够让我们通过简单的设置星期中的哪一天这个域来将我们的时间调整为星期五。注意到这里我们使用了常量 DAY_OF_WEEK 和 FRIDAY来增强代码的可读性。add 方法让我们能够在日期上加上数值，润年的所有复杂的计算都由这个方法自动处理。

我们这个例子的输出结果是:

System Date: Saturday，September 29，2001

当我们将它设置成星期五以后就成了:

Friday，September 13，

Friday，June 13，

Friday，February 13，

Friday，May 13，

Friday，January 13，

Friday，April 13，

有了这些Date 和Calendar 类的例子，你应该能够使用 java.util.Date，java.text.SimpleDateFormat，和 java.util.GregorianCalendar 创建许多方法了。

java的学习计划 (十二)

jps用于列出Java的进程，jps可以增加参数，-m用于输出传递给Java进程的参数，-l用于输出主函数的完整路径，-v可以用于显示传递给jvm的参数，

31427 sun.tools.jps.Jps -l -m -v -Dapplication.home=/Library/Java/JavaVirtualMachines/jdk1.7.0_55.jdk/Contents/Home -Xms8m

jstat是一个可以用于观察Java应用程序运行时信息的工具，它的功能非常强大，可以通过它查看堆信息的详细情况，它的基本使用方法为：

jstat - [-t] [-h] [ []]

选项option可以由以下值组成：

jstat -class pid:显示加载class的数量，及所占空间等信息。

jstat -gc pid:可以显示gc的信息，查看gc的次数，及时间。其中最后五项，分别是young gc的次数，young gc的时间，full gc的次数，full gc的时间，gc的总时间。

jstat -gccapacity:可以显示，VM内存中三代（young,old,perm）对象的使用和占用大小，如：PGCMN显示的是最小perm的内存使用量，PGCMX显示的是perm的内存最大使用量，PGC是当前新生成的perm内存占用量，PC是但前perm内存占用量。其他的可以根据这个类推， OC是old内纯的占用量。

jstat -gcnewcapacity pid:new对象的信息及其占用量。

jstat -gcoldcapacity pid:old对象的信息及其占用量。

jstat -gcpermcapacity pid: perm对象的信息及其占用量。

jstat -printcompilation pid:当前VM执行的信息。

除了以上一个参数外，还可以同时加上两个数字，如：jstat -printcompilation 3024 250 6是每250毫秒打印一次，一共打印6次。

这些参数中最常用的参数是gcutil，下面是该参数的输出介绍以及一个简单例子：

S0 — Heap上的 Survivor space 0 区已使用空间的百分比

S1 — Heap上的 Survivor space 1 区已使用空间的百分比

E — Heap上的 Eden space 区已使用空间的百分比

YGC — 从应用程序启动到采样时发生 Young GC 的次数

YGCT– 从应用程序启动到采样时 Young GC 所用的时间(单位秒)

FGCT– 从应用程序启动到采样时 Full GC 所用的时间(单位秒)

GCT — 从应用程序启动到采样时用于垃圾回收的总时间(单位秒)

实例使用1：

[root@localhost bin]# jstat -gcutil 25444

S0 S1 E O P YGC YGCT FGC FGCT GCT

11.63 0.00 56.46 66.92 98.49 162 0.248 6 0.331 0.579

jinfo可以用来查看正在运行的Java应用程序的扩展参数，甚至在运行时修改部分参数，它的基本语法为：

jinfo可以查看运行时参数：

jinfo -flag MaxTenuringThreshold 31518

jinfo还可以在运行时修改参数值：

> jinfo -flag PrintGCDetails 31518

> jinfo -flag +PrintGCDetails 31518

> jinfo -flag PrintGCDetails 31518

jmap命令主要用于生成堆快照文件，它的使用方法如下：

> jmap -dump:format=b,file=heap.hprof 31531

Dumping heap to /Users/caojie/heap.hprof ...

获得堆快照文件之后，我们可以使用多种工具对文件进行分析，例如jhat，visual vm等。

使用jhat工具可以分析Java应用程序的堆快照文件，使用命令如下：

Reading from heap.hprof...

Dump file created Tue Nov 11 06:02:05 CST

Snapshot read, resolving...

Resolving 8781 objects...

Chasing references, expect 1 dots.

Eliminating duplicate references.

Snapshot resolved.

Started HTTP server on port 7000

Server is ready.

jhat在分析完成之后，使用HTTP服务器展示其分析结果，在浏览器中访问127.0.0.1:7000/即可得到分析结果。

jstack可用于导出Java应用程序的线程堆栈信息，语法为：

jstack可以检测死锁，下例通过一个简单例子演示jstack检测死锁的功能。java代码如下：

public class DeadLock extends Thread {

protected Object myDirect;

static ReentrantLock south = new ReentrantLock;

static ReentrantLock north = new ReentrantLock();

public DeadLock(Object obj) {

this.myDirect = obj;

if (myDirect == south) {

this.setName(”south“);

}

if (myDirect == north) {

this.setName(”north“);

public void run() {

if (myDirect == south) {

try {

north.lockInterruptibly();

try {

Thread.sleep(500);

} catch (Exception e) {

e.printStackTrace();

}

south.lockInterruptibly();

System.out.println(”car to south has passed“);

} catch (InterruptedException e1) {

System.out.println(”car to south is killed“);

} finally {

if (north.isHeldByCurrentThread())

north.unlock();

if (south.isHeldByCurrentThread())

south.unlock();

}

if (myDirect == north) {

try {

south.lockInterruptibly();

try {

Thread.sleep(500);

} catch (Exception e) {

e.printStackTrace();

}

north.lockInterruptibly();

System.out.println(”car to north has passed“);

} catch (InterruptedException e1) {

System.out.println(”car to north is killed“);

} finally {

if (north.isHeldByCurrentThread())

north.unlock();

if (south.isHeldByCurrentThread())

south.unlock();

}

public static void main(String[] args) throws InterruptedException {

DeadLock car2south = new DeadLock(south);

DeadLock car2north = new DeadLock(north);

car2south.start();

car2north.start();

Thread.sleep(1000);

}

使用jps命令查看进程号为32627，然后使用jstack -l 32637 > a.txt命令把堆栈信息打印到文件中，该文件内容如下：

检讨书大全-JT56W.cOm严选TOP:

java年终工作计划 | 学习的计划 | 学习英语的计划 | 钢琴的学习计划 | java的学习计划 | java的学习计划

Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.55-b03 mixed mode):

”Attach Listener“ daemon prio=5 tid=0x00007f8d0c803000 nid=0x3307 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”DestroyJavaVM“ prio=5 tid=0x00007f8d0b80b000 nid=0x1903 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”north“ prio=5 tid=0x00007f8d0c075000 nid=0x5103 waiting on condition [0x0000000115b06000]

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

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

- parking to wait for <0x00000007d55ab600> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

at java.ncurrent.locks.LockSupport.park(LockSupport.java:186)

at java.ncurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)

at java.ncurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)

at java.ncurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)

at java.ncurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)

at (DeadLock.java:48)

Locked ownable synchronizers:

- <0x00000007d55ab5d0> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

”south“ prio=5 tid=0x00007f8d0c074800 nid=0x4f03 waiting on condition [0x0000000115a03000]

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

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

- parking to wait for <0x00000007d55ab5d0> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

at java.ncurrent.locks.LockSupport.park(LockSupport.java:186)

at java.ncurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)

at java.ncurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)

at java.ncurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)

at java.ncurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)

at (DeadLock.java:28)

Locked ownable synchronizers:

- <0x00000007d55ab600> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

”Service Thread“ daemon prio=5 tid=0x00007f8d0c025800 nid=0x4b03 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”C2 CompilerThread1“ daemon prio=5 tid=0x00007f8d0c025000 nid=0x4903 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”C2 CompilerThread0“ daemon prio=5 tid=0x00007f8d0d01b000 nid=0x4703 waiting on condition [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”Signal Dispatcher“ daemon prio=5 tid=0x00007f8d0c02 nid=0x4503 runnable [0x0000000000000000]

java.lang.Thread.State: RUNNABLE

Locked ownable synchronizers:

”Finalizer“ daemon prio=5 tid=0x00007f8d0d004000 nid=0x3103 in Object.wait() [0x000000011526a000]

java.lang.Thread.State: WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

- waiting on <0x00000007d5505568> (a java.lang.ref.ReferenceQueue$Lock)

at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)

- locked <0x00000007d5505568> (a java.lang.ref.ReferenceQueue$Lock)

at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)

at java.lang.ref.Finalizer$(Finalizer.java:189)

Locked ownable synchronizers:

”Reference Handler“ daemon prio=5 tid=0x00007f8d0d001800 nid=0x2f03 in Object.wait() [0x0000000115167000]

java.lang.Thread.State: WAITING (on object monitor)

at java.lang.Object.wait(Native Method)

- waiting on <0x00000007d55050f0> (a java.lang.ref.Reference$Lock)

at java.lang.Object.wait(Object.java:503)

at java.lang.ref.Reference$(Reference.java:133)

- locked <0x00000007d55050f0> (a java.lang.ref.Reference$Lock)

Locked ownable synchronizers:

”VM Thread“ prio=5 tid=0x00007f8d0b83b000 nid=0x2d03 runnable

”GC task thread#0 (ParallelGC)“ prio=5 tid=0x00007f8d0b818000 nid=0x2503 runnable

”GC task thread#1 (ParallelGC)“ prio=5 tid=0x00007f8d0b819000 nid=0x2703 runnable

”GC task thread#2 (ParallelGC)“ prio=5 tid=0x00007f8d0d000000 nid=0x2903 runnable

”GC task thread#3 (ParallelGC)“ prio=5 tid=0x00007f8d0d001000 nid=0x2b03 runnable

”VM Periodic Task Thread“ prio=5 tid=0x00007f8d0c02e800 nid=0x4d03 waiting on condition

Found one Java-level deadlock:

=============================

”north“:

waiting for ownable synchronizer 0x00000007d55ab600, (a java.ncurrent.locks.ReentrantLock$NonfairSync),

which is held by ”south“

”south“:

waiting for ownable synchronizer 0x00000007d55ab5d0, (a java.ncurrent.locks.ReentrantLock$NonfairSync),

which is held by ”north“

Java stack information for the threads listed above:

===================================================

”north“:

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

- parking to wait for <0x00000007d55ab600> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

at java.ncurrent.locks.LockSupport.park(LockSupport.java:186)

at java.ncurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)

at java.ncurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)

at java.ncurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)

at java.ncurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)

at (DeadLock.java:48)

”south“:

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

- parking to wait for <0x00000007d55ab5d0> (a java.ncurrent.locks.ReentrantLock$NonfairSync)

at java.ncurrent.locks.LockSupport.park(LockSupport.java:186)

at java.ncurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)

at java.ncurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)

at java.ncurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)

at java.ncurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)

at (DeadLock.java:28)

Found 1 deadlock.

从这个输出可以知道：

1、在输出的最后一段，有明确的”Found one Java-level deadlock“输出，所以通过jstack命令我们可以检测死锁；

2、输出中包含了所有线程，除了我们的north,sorth线程外，还有”Attach Listener“, ”C2 CompilerThread0“, ”C2 CompilerThread1“等等；

3、每个线程下面都会输出当前状态，以及这个线程当前持有锁以及等待锁，当持有与等待造成循环等待时，将导致死锁，

jstatd命令是一个RMI服务器程序，它的作用相当于代理服务器，建立本地计算机与远程监控工具的通信，jstatd服务器能够将本机的Java应用程序信息传递到远程计算机，由于需要多台计算机做演示，此处略。

hprof工具可以用于监控Java应用程序在运行时的CPU信息和堆信息，关于hprof的官方文档如下：docs.javase/7/docs/technotes/samples/hprof.html

Visual VM是一个功能强大的多合一故障诊断和性能监控的可视化工具，它集成了多种性能统计工具的功能，使用Visual VM可以替代jstat、jmap、jhat、jstack等工具。在命令行输入jvisualvm即可启动visualvm。

打开Visual VM之后，左边导航栏会显示出当前机器所有Java进程：

点击你想监控的程序即可对该程序进行监控，Visual VM的性能监控页一共有以下几个tab页：

概述页会显示程序的基本使用情况，比如，进程ID，系统属性，启动参数等。

通过监视页面，可以监视应用程序的CPU、堆、永久区、类加载器和线程数的整体情况，通过页面上的Perform. GC和Heap Dump按钮还可以手动执行Full GC和生成堆快照。

线程页面会提供详细的线程信息，单击Thread Dump按钮可以导出当前所有线程的堆栈信息，如果Visual VM在当前线程中找到死锁，则会以十分显眼的方式在Threads页面给予提示。

抽样器可以对CPU和内存两个性能进行抽样，用于实时地监控程序。CPU采样器可以将CPU占用时间定位到方法，内存采样器可以查看当前程序的堆信息。下面是一个频繁调用的Java程序，我们会对改程序进行采样：

public class MethodTime {

static java.util.Random r=new java.util.Random();

static Map map=null;

static{

map=new HashMap();

map.put(”1“, ”Java“);

map.put(”2“, ”C++“);

map.put(”3“, ”Delphi“);

map.put(”4“, ”C“);

map.put(”5“, ”Phython“);

}

public String getNameById(String id){

try {

Thread.sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

return map.get(id);

}

public List getNamesByIds(String ids){

List re=new ArrayList();

String[] strs=ids.split(”,“);

re.add(getNameById(id));

}

return re;

}

public List getNamesByIdsBad(String ids){

List re=new ArrayList();

String[] strs=ids.split(”,“);

getNameById(id);

re.add(getNameById(id));

}

return re;

}

public class NamesByIdsThread implements Runnable{

public void run() {

try{

while(true){

int c=r.nextInt(4);

String ids=”“;

for(int i=0;i

ids=Integer.toString((r.nextInt(4)+1))+”,“;

getNamesByIds(ids);

}

}catch(Exception e){

}

public class NamesByIdsBadThread implements Runnable{

public void run() {

try{

while(true){

int c=r.nextInt(4);

String ids=”“;

for(int i=0;i

ids=Integer.toString((r.nextInt(4)+1))+”,“;

getNamesByIdsBad(ids);

}

}catch(Exception e){

}

public static void main(String args[]){

MethodTime instance=new MethodTime();

new Thread(instance.new NamesByIdsThread()).start();

new Thread(instance.new NamesByIdsBadThread()).start();

}

通过Visual VM的采样功能，可以找到改程序中占用CPU时间最长的方法：

默认Visual VM不统计内置对象的函数调用，比如java.*包中的类，如果要统计这些内置对象，单机右上角的设置进行调配。Visual VM虽然可以统计方法的调用时间，但是无法给出方法调用堆栈，Jprofile不仅可以给出方法调用时间，还可以给出方法调用堆栈，较Visual VM更强大。

右击左导航的应用程序，会出现以下菜单：

单机应用程序快照，可以分析当前应用程序的快照，单击堆Dump能够对当前的堆信息进行分析。Visual VM的更多使用方法，可以查看Oracle的官方文档docs.javase/7/docs/technotes/guides/visualvm/

BTrace是一款功能强大的性能检测工具，它可以在不停机的情况下，通过字节码注入，动态监控系统的运行情况，它可以跟踪指定的方法调用、构造函数调用和系统内存等信息，本部分打算举一个例子，讲解一下BTrace的使用。要在Visual VM中使用Btrace，首先需要安装Btrace插件，点击工具->插件即可在线安装，安装后右键应用程序，就会出现如下选项：

点击Trace application，即可进入BTrace插件界面。使用BTrace可以监控指定函数的耗时，以下脚本通过正则表达式，监控所有类的getNameById方法：

import com.sun.btrace.annotations.*;

import static com.sun.btrace.BTraceUtils.*;

public class TracingScript. {

private static long startTime = 0;

@OnMethod(clazz=”/.+/“, method=”/getNameById/“)//监控任意类的getNameById方法

public static void startMethod() {

startTime=timeMillis();

}

@OnMethod(clazz=”/.+/“, method=”/getNameById/“,

location=@Location(Kind.RETURN))//方法返回时触发

public static void endMethod() {