java

lockxxx - 经理五级 正解

if(email.indexOf("@",0)==-1||email.indexOf(".",0)==-1){ alert("此为不正确的邮件格式。必须包含"@"和"."~~~~~"); return;}if(email.indexOf("@",0)==0||email.indexOf("@",0)==email.length-1){alert(""@"不能在最前端或最后端~~~~~");return;}if(email.indexOf(".",0)==0||email.indexOf(".",0)==email.length-1){alert(""."不能在最前端或最后端~~~~~");return;}if(email.indexOf(".",0)-(email.indexOf("@",0))<=0){alert(""."必须在"@"的后面~~~~~");return;}if(email.indexOf(".",0)-(email.indexOf("@",0))<=1){alert(""@"和"."中间必须有字符~~~~~");return;}就这个意思，你应该看的懂吧~~~

呵呵 你虽然方法中用了返回，但是你没有把值给打印出来啊，当然什么都不会显示了，用个输出语句就可以了。

返回指定字符在此字符串中第一次出现处的索引。

是电脑的语言

array是数组，但是里面5是什么意思，没有代码就不知道了，看样子好像是调用方法array传的参数是5！要代码才知道。。。。。

看书

知己手机

很明显是MTK平台 是新版的MTK平台 应该支持QQ的 JAVA 很少

少买买这样的手机 破手机 一个 它只能当MP4 用 我买的那个手机还乱扣费呢 我还在想怎么办呢！~ 要买就买品牌机吧 我也上当了！！！5555555555555

import java.util.*;public class Combination{ public static void main(String[] args) { Vector testData = new Vector(Arrays.asList(1, 2, 3, 4, 5, 6)); Vector results = getAllCombinations(testData); for(int i=0; i<results.size(); i++) System.out.println(results.elementAt(i)); } public static Vector getAllCombinations(Vector data) { Vector allCombinations = new Vector(); for(int i=1; i<=data.size(); i++) { Vector initialCombination = new Vector(); allCombinations.addAll(getAllCombinations(data, i)); } return allCombinations; } public static Vector getAllCombinations(Vector data, int length) { Vector allCombinations = new Vector(); Vector initialCombination = new Vector(); combination(allCombinations, data, initialCombination, length); return allCombinations; } private static void combination(Vector allCombinations, Vector data, Vector initialCombination, int length) { if(length == 1) { for(int i=0; i<data.size(); i++) { Vector newCombination = new Vector(initialCombination); newCombination.add(data.elementAt(i)); allCombinations.add(newCombination); } } if(length > 1) { for(int i=0; i<data.size(); i++) { Vector newCombination = new Vector(initialCombination); newCombination.add(data.elementAt(i)); Vector newData = new Vector(data); for(int j=0; j<=i; j++) newData.remove(data.elementAt(j)); combination(allCombinations, newData, newCombination, length - 1); } } }}

如果没有负整数，一共有 8037 种拆法。源码：import java.io.FileWriter;import java.io.IOException;import java.util.Arrays;import java.util.Set;import java.util.TreeSet;public class Main {public final static int Sum = 100;static Set<String> Combinations = new TreeSet<>();public static void main(String[] args) throws IOException {for (int i1 = 0; i1 <= Sum; i1++) {for (int i2 = 0; i2 <= Sum; i2++) {for (int i3 = 0; i3 <= Sum; i3++) {for (int i4 = 0; i4 <= Sum; i4++) {String s = GetString(new int[] {i1, i2, i3, i4});if (CheckNumbers(i1, i2, i3, i4)) {Combinations.add(s);}}}}}System.out.println(Combinations);System.out.println(Combinations.size());FileWriter writer = new FileWriter("results.json");writer.write(Combinations.toString());writer.flush();writer.close();}public static String GetString(int[] numbers) {sort(numbers, 0, 3);return Arrays.toString(numbers);}public static void sort(int[] arr,int begin,int end) {int a = begin;int b = end;if (a >= b) return;int x = arr[a];while (a < b) {while (a < b && arr[b] >= x) b--;if (a < b) {arr[a] = arr[b];a++;}while (a < b && arr[a] <= x) a++;if (a < b) {arr[b] = arr[a];b--;}}arr[a] = x;sort(arr,begin,a-1);sort(arr,a+1,end);}public static boolean CheckNumbers(int i1, int i2, int i3, int i4) {return (i1 + i2 + i3 + i4) == Sum;}}

遍历。8037 种。import java.io.FileWriter;import java.io.IOException;import java.util.Arrays;import java.util.Set;import java.util.TreeSet;public class Main {public final static int Sum = 100;static Set<String> Combinations = new TreeSet<>();public static void main(String[] args) throws IOException {for (int i1 = 0; i1 <= Sum; i1++) {for (int i2 = 0; i2 <= Sum; i2++) {for (int i3 = 0; i3 <= Sum; i3++) {for (int i4 = 0; i4 <= Sum; i4++) {String s = GetString(new int[] {i1, i2, i3, i4});if (CheckNumbers(i1, i2, i3, i4)) {Combinations.add(s);}}}}}System.out.println(Combinations);System.out.println(Combinations.size());FileWriter writer = new FileWriter("results.json");writer.write(Combinations.toString());writer.flush();writer.close();}public static String GetString(int[] numbers) {sort(numbers, 0, 3);return Arrays.toString(numbers);}public static void sort(int[] arr,int begin,int end) {int a = begin;int b = end;if (a >= b) return;int x = arr[a];while (a < b) {while (a < b && arr[b] >= x) b--;if (a < b) {arr[a] = arr[b];a++;}while (a < b && arr[a] <= x) a++;if (a < b) {arr[b] = arr[a];b--;}}arr[a] = x;sort(arr,begin,a-1);sort(arr,a+1,end);}public static boolean CheckNumbers(int i1, int i2, int i3, int i4) {return (i1 + i2 + i3 + i4) == Sum;}}

检查该段代码是否为死循环，是否是处理数据量多大导致java环境配置内存不足。

在解决java内存溢出问题之前，需要对jvm（java虚拟机）的内存管理有一定的认识。jvm管理的内存大致包括三种不同类型的内存区域：Permanent Generation space（永久保存区域）、Heap space(堆区域)、Java Stacks(Java栈）。其中永久保存区域主要存放Class（类）和Meta的信息，Class第一次被Load的时候被放入PermGen space区域，Class需要存储的内容主要包括方法和静态属性。堆区域用来存放Class的实例（即对象），对象需要存储的内容主要是非静态属性。每次用new创建一个对象实例后，对象实例存储在堆区域中，这部分空间也被jvm的垃圾回收机制管理。而Java栈跟大多数编程语言包括汇编语言的栈功能相似，主要基本类型变量以及方法的输入输出参数。Java程序的每个线程中都有一个独立的堆栈。容易发生内存溢出问题的内存空间包括：Permanent Generation space和Heap space。第一种OutOfMemoryError： PermGen space发生这种问题的原意是程序中使用了大量的jar或class，使java虚拟机装载类的空间不够，与Permanent Generation space有关。解决这类问题有以下两种办法：增加java虚拟机中的XX:PermSize和XX:MaxPermSize参数的大小，其中XX:PermSize是初始永久保存区域大小，XX:MaxPermSize是最大永久保存区域大小。如针对tomcat6.0，在catalina.sh 或catalina.bat文件中一系列环境变量名说明结束处（大约在70行左右） 增加一行： JAVA_OPTS=" -XX:PermSize=64M -XX:MaxPermSize=128m" 如果是windows服务器还可以在系统环境变量中设置。感觉用tomcat发布sprint+struts+hibernate架构的程序时很容易发生这种内存溢出错误。使用上述方法，我成功解决了部署ssh项目的tomcat服务器经常宕机的问题。清理应用程序中web-inf/lib下的jar，如果tomcat部署了多个应用，很多应用都使用了相同的jar，可以将共同的jar移到tomcat共同的lib下，减少类的重复加载。这种方法是网上部分人推荐的，我没试过，但感觉减少不了太大的空间，最靠谱的还是第一种方法。第二种OutOfMemoryError： Java heap space发生这种问题的原因是java虚拟机创建的对象太多，在进行垃圾回收之间，虚拟机分配的到堆内存空间已经用满了，与Heap space有关。解决这类问题有两种思路：检查程序，看是否有死循环或不必要地重复创建大量对象。找到原因后，修改程序和算法。 我以前写一个使用K-Means文本聚类算法对几万条文本记录（每条记录的特征向量大约10来个）进行文本聚类时，由于程序细节上有问题，就导致了Java heap space的内存溢出问题，后来通过修改程序得到了解决。增加Java虚拟机中Xms（初始堆大小）和Xmx（最大堆大小）参数的大小。如：set JAVA_OPTS= -Xms256m -Xmx1024m第三种OutOfMemoryError：unable to create new native thread在java应用中，有时候会出现这样的错误：OutOfMemoryError: unable to create new native thread.这种怪事是因为JVM已经被系统分配了大量的内存(比如1.5G)，并且它至少要占用可用内存的一半。有人发现，在线程个数很多的情况下，你分配给JVM的内存越多，那么，上述错误发生的可能性就越大。那么是什么原因造成这种问题呢？每一个32位的进程最多可以使用2G的可用内存，因为另外2G被操作系统保留。这里假设使用1.5G给JVM，那么还余下500M可用内存。这500M内存中的一部分必须用于系统dll的加载，那么真正剩下的也许只有400M，现在关键的地方出现了：当你使用Java创建一个线程，在JVM的内存里也会创建一个Thread对象，但是同时也会在操作系统里创建一个真正的物理线程(参考JVM规范)，操作系统会在余下的400兆内存里创建这个物理线程，而不是在JVM的1500M的内存堆里创建。在jdk1.4里头，默认的栈大小是256KB，但是在jdk1.5里头，默认的栈大小为1M每线程，因此，在余下400M的可用内存里边我们最多也只能创建400个可用线程。这样结论就出来了，要想创建更多的线程，你必须减少分配给JVM的最大内存。还有一种做法是让JVM宿主在你的JNI代码里边。给出一个有关能够创建线程的最大个数的估算公式：(MaxProcessMemory - JVMMemory - ReservedOsMemory) / (ThreadStackSize) = Number of threads对于jdk1.5而言，假设操作系统保留120M内存：1.5GB JVM: (2GB-1.5Gb-120MB)/(1MB) = ~380 threads1.0GB JVM: (2GB-1.0Gb-120MB)/(1MB) = ~880 threads对于栈大小为256KB的jdk1.4而言，1.5GB allocated to JVM: ~1520 threads1.0GB allocated to JVM: ~3520 threads 对于这个异常我们首先需要判断下，发生内存溢出时进程中到底都有什么样的线程，这些线程是否是应该存在的，是否可以通过优化来降低线程数； 另外一方面默认情况下java为每个线程分配的栈内存大小是1M，通常情况下，这1M的栈内存空间是足足够用了，因为在通常在栈上存放的只是基础类型的数据或者对象的引用，这些东西都不会占据太大的内存， 我们可以通过调整jvm参数，降低为每个线程分配的栈内存大小来解决问题，例如在jvm参数中添加-Xss128k将线程栈内存大小设置为128k。

是的，线程太多了

你用的什么IDE，eclipse？

内存溢出类型　　1 、 java.lang.OutOfMemoryError: PermGen space　　JVM 经管两种类型的内存，堆和非堆。堆是给开辟人员用的上方说的就是，是在 JVM 启动时创建;非堆是留给 JVM 本身用的，用来存放类的信息的。它和堆不合，运行期内 GC 不会开释空间。若是 web app 用了多量的第三方 jar 或者应用有太多的 class 文件而正好 MaxPermSize 设置较小，超出了也会导致这块内存的占用过多造成溢出，或者 tomcat 热安排时侯不会清理前面加载的景象，只会将 context 更改为新安排的，非堆存的内容就会越来越多。　　2 、 java.lang.OutOfMemoryError: Java heap space　　第一种景象是个补充，首要存在题目就是呈如今这个景象中。其默认空间 ( 即 -Xms) 是物理内存的 1/64 ，最大空间 (-Xmx) 是物理内存的 1/4 。若是内存残剩不到 40 %， JVM 就会增大堆到 Xmx 设置的值，内存残剩跨越 70 %， JVM 就会减小堆到 Xms 设置的值。所以办事器的 Xmx 和 Xms 设置一般应当设置雷同避免每次 GC 后都要调剂虚拟机堆的大小。假设物理内存无穷大，那么 JVM 内存的最大值跟操纵体系有关，一般 32 位机是 1.5g 到 3g 之间，而 64 位的就不会有限制了。　　重视：若是 Xms 跨越了 Xmx 值，或者堆最大值和非堆最大值的总和跨越了物理内存或者操纵体系的最大限制都邑引起办事器启动不起来。　　垃圾收受接管 GC 的角色　　JVM 调用 GC 的频度还是很高的，首要两种景象下进行垃圾收受接管：　　当应用法度线程余暇;另一个是 java 内存堆不足时，会络续调用 GC ，若连气儿收受接管都解决不了内存堆不足的题目时，就会报 out of memory 错误。因为这个异常按照体系运行景象决意，所以无法预期它何时呈现。　　按照 GC 的机制，法度的运行会引起体系运行景象的变更，增长 GC 的触发机会。　　为了避免这些题目，法度的设计和编写就应避免垃圾对象的内存占用和 GC 的开销。显示调用 System.GC() 只能建议 JVM 须要在内存中对垃圾对象进行收受接管，但不是必须即速收受接管，　　一个是并不克不及解决内存资料耗空的场合排场，别的也会增长 GC 的消费。

在myeclipse上边找到“Window”--"Preference",在搜索框中输入“tomcat”找到自己tomcat的版本，点击下方的jdk在右侧Optional Java VM arguments 输入-Xms256M -Xmx512M -XX:PermSize=256m -XX:MaxPermSize=512m即可，值也可以根据自己的需要调整，点击下方“Apply”--"OK"重启tomcat就不再报错了

如果你的语句是 web 服务器里，执行的话，那么修改JAVA参数比如 jboss 的 run.batset JAVA_OPTS=%JAVA_OPTS% -Xms256m -Xmx768m -Xss128k如果是在 eclipse里，那么修改eclipse的eclipse.ini设置。

java堆，内存溢出。。。

那是安装问题吧，4核8G就挺可以了，4G也可以了

Connection con = null;ResultSet rs = null;PreparedStatement pst = null;try {con = DBCon.getConnection();con.setAutoCommit(false);pst = con.prepareStatement(" select * from test ");rs = pst.executeQuery();pst = con.prepareStatement(" insert into test1(t1,t2,t3,t4,t5,t6,t7,t8,t9)values(?,?,?,?,?,?,?,?,?) ");while (rs.next()) {pst.setString(1, rs.getString(1));pst.setString(2, rs.getString(2));pst.setString(3, rs.getString(3));pst.setString(4, rs.getString(4));pst.setString(5, rs.getString(5));pst.setString(6, rs.getString(6));pst.setString(7, rs.getString(7));pst.setString(8, rs.getString(8));pst.setString(9, rs.getString(9));pst.addBatch();}pst.executeBatch();} catch (SQLException e) {// TODO: handle exception} finally {try {rs.close();pst.close();con.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}

那么麻烦干嘛，重新安装JAVA X64

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

java heap space的意思为“java堆空间”，是JAVA的堆栈设置太小的原因。有这两种解决方法：1、设置环境变量：set JAVA_OPTS= -Xms32m -Xmx512m可以根据自己机器的内存进行更改，但本人测试这种方法并没有解决问题。可能是还有哪里需要设置。2、java -Xms32m -Xmx800m className：就是在执行JAVA类文件时加上这个参数，其中className是需要执行的确类名。这个解决问题了，而且执行的速度比没有设置的时候快很多。如果在测试的时候可能会用Eclispe这时候就需要在Eclipse ->run -arguments中的VM arguments中输入－Xms32m -Xmx800m这个参数就可以了。

Java堆空间（Heap Space）是指Java程序运行时使用的一块内存空间，用于存储对象实例、数组、常量池等数据。堆空间的大小由JVM决定，并且可以通过调整JVM参数来进行调整。在Java中，每个线程都拥有一个虚拟机栈，用于存储栈帧信息。堆是JVM内存空间中最大的一块，每个对象实例都要分配在堆上，并且在堆上分配的对象实例必须是引用类型，即它们必须指向其他对象或者数组。由于即时编译技术的进步，逃逸分析技术的日渐强大，栈上分配、标量替换优化手段已经导致一些微妙的变化悄然发生，因此虽然Java对象实例都分配在堆上也不是绝对的。但是在多线程环境下，由于线程之间的竞争关系，堆空间的使用仍然是很重要的，需要仔细分析和调整JVM参数来最大化堆空间的使用效率。

StringBuffer支持很大的数据，你这才200M就内存溢出，显然是jvm内存分配不足。1、调大jvn的内存。2、修改程序，用缓存实现，不要一次全部读取出来。分次执行。

超出虚拟机内存了吧，改下jvm内存，网上有很多设置的帖子的

堆空间不够用。需要改tomcat启动参数。把堆空间和方法区控件都扩大。扩多大，看你的项目了。你的项目多大，你的参数又是多少，贴一下，我帮你看看。

你分析下你的代码是不是哪个地方有的连接或流什么的没有及时关闭。还有就是里边执行时进入了死循环。。

做分页处理

重新检查下JAVA_HOME，PATH，CLASSPATH。。我安装android Studio的时候也出现过你这情况，设置好了JAVA_HOME，PATH，CLASSPATH之后就能启动了

首先检查代码。看是否有数据集未释放，特别是多个ResultSet这间的嵌套使用。像你这种情况，打开一次数据连接，不要反复的关闭，打开连接，这样很消耗资源的。再你尝试在Eclipse -> Edit JRE -> Default VM Arguments：-Xms256m -Xmx512m

方法/步骤 1) 进入 Mabab 的安装路径 F:MATLAB6p5inwin32 2) 在该目录下创建一个空文件，取名为 "wtsapi32.dll" 3) 如果你是WIN7或其他版本，右击-属性-兼容性，修改兼容性为Vista或XP 4) 重新启动Mablab

可能是某个地方出现死循环了..也肯能是文件太大了吧.String line = br.readLine(); 把line的定义放在外面试一试额.

说明图片可能有点大，尝试加大运行时的内存：运行时加上参数 -Xmx1024m另外最好还是要判断下oom的具体原因，OOM可能会发生在不同的存储位置，可以通过具体的设置去增加不同位置内存的占用。关注我的微公号 某鸟碎碎， 发布各种入门教学文章，java编程基础学习内容。

JAVA_OPTS = -server -Xms1024m -Xmx1024m可参考以下网址，自行设置。http://blog.csdn.net/happyitlife/article/details/7291182

可见的代码上需要一处需要优化，in需要关闭！！！

首先找到源出问题的代码块先。一般网上都是说设置大点的内存。但我觉得问题要从代码开始解决。当然，也可适度调大内存。

解决办法1：把extjs4的工程安装包不要放到web工程中就ok或者建议直接用myeclipse直接导入的exjts4包，就没问题。解决办法2：导入ExtJS包，这样会卡死eclipse的。去到工程根目录下，找到.project，用记事本打开，把两处删除掉：第一处：<buildCommand><name>org.eclipse.wst.jsdt.core.javascriptValidator</name><arguments></arguments></buildCommand>第二处：<nature>org.eclipse.wst.jsdt.core.jsNature</nature>保存退出，refresh一下工程。再把ext包复制进工程你试试这个解决方法。

解决办法：1.window->preferences->java->installed jres->edit jre把default vm arguments 的参数设为-Xms64m -Xmx512方法2。在window的环境变量中添加JAVA_OPTS=-Xms64m -Xmx512m

这个不太清楚

是不是你启动的Tomcat没有关闭就新建导致的

第一种 环境myeclipse修改在菜单window->preferecces.在JDK对话框中输入-Xms512m -Xmx1024m这个参数就可以了。第二种 tomcat安装版修改方法：第三种 tomcat绿色版修改方法。在bin目录下找到catalina.bat；在:gotHome后输入[html] view plain copy set "JAVA_OPTS=-Xms512m -Xmx1024m"

建议重装系统

java内存空间中的堆区域（用于存放java的对象）发生了内存溢出，两个原因：1、你的应用比较消耗内存空间，需要较大的堆空间，而你设置的内存不够。2、你的程序有BUG，没有及时释放对象，最终消耗了过多的内存。需要排查。解决方案：1、调大JVM内存， -Xmx:521M ，或更多2、优化程序

在myeclipse中出现：java.lang.OutOfMemoryError: Java heap space 或着java.lang.OutOfMemoryError: PermGen space 这两个错误，原因是tomcat 或着mycelispe没有设置好 如是单独启动tomcat出现这个问题，应该在如apache-tomcat-5.5.25incatalina.bat文件中 添加set CATALINA_OPTS=-Xms512m -Xmx1048m -XX:PermSize=128m -XX:MaxPermSize=400m 根据自己机器的实际情况决定，默认MaxPermSize为128,这个地方设置的也不能太大的，如果太大的话，运行startup.bat将会一闪而过，启动不了tomcat 如果是在myeclipse中启动出现这个问题，要是myeclipse中设置tomcat的启动参数 路径：Myeclipse->preferences->myeclipse->servers->tomcat->tomcat×.×->下， -Xms1024M -Xmx1024M -XX:MaxPermSize=400M不设置就算tomcat中设置了，也还是按默认的128M运行，这里的设置也要根据自己的机器的实际情况来定。

堆栈不够了加这个set JAVA_OPTS= -Xms32m -Xmx512m

内存溢出了. 吧JAVA虚拟机的内存配高点就行了.

1、OutOfMemoryError 是java内存溢出错误，但内存溢出也分成很多类。2、java heap space 主要是指堆栈溢出。理论上调整jvm内存设置，是可以一定程度上缓解这个问题的。但是也不能设置过大。3、这个时候主要还是应该检查你的代码，尤其是复杂数据结构和循环，检查有无内存泄露，有些复杂数据结构用完有无及时清空。4、你可以用一些检查java内存泄露的工具。5、希望对你有帮助。

使用Java程序从数据库中查询大量的数据时出现异常:java.lang.OutOfMemoryError: Java heap space在JVM中如果98％的时间是用于GC且可用的 Heap size 不足2％的时候将抛出此异常信息。JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。例如：java -jar -Xmn16m -Xms64m -Xmx128m MyApp.jar如果Heap Size设置偏小，除了这些异常信息外，还会发现程序的响应速度变慢了。GC占用了更多的时间，而应用分配到的执行时间较少。Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred during initialization of VM Could not reserve enough space for object heap”。

首先先说一下JVM内存结构问题，JVM为两块：PermanentSapce和HeapSpace，其中x0dx0aHeap = }。PermantSpace负责保存反射对象，一般不用配置。JVM的Heap区可以通过-X参数来设定。x0dx0a 当一个URL被访问时，内存申请过程如下：x0dx0aA. JVM会试图为相关Java对象在Eden中初始化一块内存区域x0dx0aB. 当Eden空间足够时，内存申请结束。否则到下一步x0dx0aC. JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区x0dx0aD. Survivor区被用来作为Eden及OLD的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区x0dx0aE. 当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）x0dx0aF. 完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现”out of memory错误”x0dx0ax0dx0aJVM调优建议:x0dx0ax0dx0ams/mx：定义YOUNG+OLD段的总尺寸，ms为JVM启动时YOUNG+OLD的内存大小；mx为最大可占用的YOUNG+OLD内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。x0dx0aNewSize/MaxNewSize：定义YOUNG段的尺寸，NewSize为JVM启动时YOUNG的内存大小；MaxNewSize为最大可占用的YOUNG内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。x0dx0aPermSize/MaxPermSize：定义Perm段的尺寸，PermSize为JVM启动时Perm的内存大小；MaxPermSize为最大可占用的Perm内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。x0dx0aSurvivorRatio：设置Survivor空间和Eden空间的比例x0dx0ax0dx0a内存溢出的可能性x0dx0ax0dx0a1. OLD段溢出x0dx0a这种内存溢出是最常见的情况之一，产生的原因可能是：x0dx0a1) 设置的内存参数过小(ms/mx, NewSize/MaxNewSize)x0dx0a2) 程序问题x0dx0a单个程序持续进行消耗内存的处理，如循环几千次的字符串处理，对字符串处理应建议使用StringBuffer。此时不会报内存溢出错，却会使系统持续垃圾收集，无法处理其它请求，相关问题程序可通过Thread Dump获取（见系统问题诊断一章）单个程序所申请内存过大，有的程序会申请几十乃至几百兆内存，此时JVM也会因无法申请到资源而出现内存溢出，对此首先要找到相关功能，然后交予程序员修改，要找到相关程序，必须在Apache日志中寻找。x0dx0a当Java对象使用完毕后，其所引用的对象却没有销毁，使得JVM认为他还是活跃的对象而不进行回收，这样累计占用了大量内存而无法释放。由于目前市面上还没有对系统影响小的内存分析工具，故此时只能和程序员一起定位。x0dx0ax0dx0a2. Perm段溢出x0dx0a通常由于Perm段装载了大量的Servlet类而导致溢出，目前的解决办法：x0dx0a1) 将PermSize扩大，一般256M能够满足要求x0dx0a2) 若别无选择，则只能将servlet的路径加到CLASSPATH中，但一般不建议这么处理x0dx0ax0dx0a3. C Heap溢出x0dx0a系统对C Heap没有限制，故C Heap发生问题时，Java进程所占内存会持续增长，直到占用所有可用系统内存x0dx0ax0dx0a参数说明:x0dx0ax0dx0aJVM 堆内存（heap）设置选项 x0dx0a 参数格式 x0dx0a 说 明 x0dx0a x0dx0a设置新对象生产堆内存（Setting the Newgeneration heap size） x0dx0a -XX:NewSize x0dx0a 通过这个选项可以设置Java新对象生产堆内存。在通常情况下这个选项的数值为1 024的整数倍并且大于1MB。这个值的取值规则为，一般情况下这个值-XX:NewSize是最大堆内存（maximum heap size）的四分之一。增加这个选项值的大小是为了增大较大数量的短生命周期对象 x0dx0ax0dx0a增加Java新对象生产堆内存相当于增加了处理器的数目。并且可以并行地分配内存，但是请注意内存的垃圾回收却是不可以并行处理的 x0dx0a x0dx0a设置最大新对象生产堆内存（Setting the maximum New generation heap size） x0dx0a -XX:MaxNewSize x0dx0a 通过这个选项可以设置最大Java新对象生产堆内存。通常情况下这个选项的数值为1 024的整数倍并且大于1MB x0dx0ax0dx0a其功用与上面的设置新对象生产堆内存-XX：NewSize相同x0dx0ax0dx0a设置新对象生产堆内存的比例（Setting New heap size ratios） x0dx0a -XX:SurvivorRatio x0dx0a 新对象生产区域通常情况下被分为3个子区域：伊甸园，与两个残存对象空间，这两个空间的大小是相同的。通过用-XX:SurvivorRatio=X选项配置伊甸园与残存对象空间（Eden/survivor）的大小的比例。你可以试着将这个值设置为8，然后监控、观察垃圾回收的工作情况x0dx0ax0dx0a设置堆内存池的最大值（Setting maximum heap size） x0dx0a -Xmx x0dx0a 通过这个选项可以要求系统为堆内存池分配内存空间的最大值。通常情况下这个选项的数值为1 024的整数倍并且大于1 MB x0dx0ax0dx0a一般情况下这个值（-Xmx）与最小堆内存（minimum heap size _Xms）相同，以降低垃圾回收的频度 x0dx0a x0dx0a取消垃圾回收 x0dx0a -Xnoclassgc x0dx0a 这个选项用来取消系统对特定类的垃圾回收。它可以防止当这个类的所有引用丢失之后，这个类仍被引用时不会再一次被重新装载，因此这个选项将增大系统堆内存的空间 x0dx0a x0dx0a设置栈内存的大小 x0dx0a -Xss x0dx0a 这个选项用来控制本地线程栈的大小，当这个选项被设置的较大（>2MB）时将会在很大程度上降低系统的性能。因此在设置这个值时应该格外小心，调整后要注意观察系统的性能，不断调整以期达到最优 x0dx0a x0dx0a最后说一句，你的机器的连接数设置也至关重要，连接的关闭最好把时间设置的少些，那些连接非常耗费资源。也是引起内存泄露的主要原因。

Java堆空间，指的是JVM在内存中管理对象实例的内存区域，是存放对象实例的最大内存区域，所有的对象实例都在这里分配内存。

continue在java中是跳出本次循环，继续执行下一次循环，举例：x0dx0afor(int i=0;i<10;1++){x0dx0aif(i==5){x0dx0acontinue;x0dx0a}else{x0dx0aSystem.out.print(i);x0dx0a}x0dx0ax0dx0a}x0dx0a解释：上面的语句就是当i的值是5的话，直接跳过此次循环，直接i=6，继续for循环，之后输出的结果就是0-9（不包含5）；x0dx0a备注：还有个一“break”，这个的意思是跳出本层循环，也就是结束循环，如果上面的continue换成break，那么输出结果就是：1-4；

continue在java中是跳出本次循环，继续执行下一次循环，举例：for(int i=0;i<10;1++){if(i==5){continue;}else{System.out.print(i);}}解释：上面的语句就是当i的值是5的话，直接跳过此次循环，直接i=6，继续for循环，之后输出的结果就是0-9（不包含5）；备注：还有个一“break”，这个的意思是跳出本层循环，也就是结束循环，如果上面的continue换成break，那么输出结果就是：1-4；

你是想从后台返回到前台解析还是在后台解析？不是很明白你的意思！

这个面向切面编程,@Aspect 就是注解方式来注册切面的

aspect关键字是Java 1.5之后才有的。

前缀和后缀比如 prefix ="resume/"suffix=".jsp"请求路径是resume/add.jsp你只要输入add就可以了系统自动就会加上

prefix suffix是spring MVC试图解析器的一个属性， prefix ： 是指访问页面的前缀，指定页面存放的文件夹 suffix ： 是指文件的后缀名，常见的后缀名有html,jsp,php,txt,mp3

prefix suffix是spring MVC试图解析器的一个属性，prefix ： 是指访问页面的前缀，指定页面存放的文件夹suffix ： 是指文件的后缀名，常见的后缀名有html,jsp,php,txt,mp3

当一个Assembly被加载到AppDomain之后，静态数据被加载，在其中创建的对象GC会负责回收 但是除非这个AppDomain被卸载，否则这个Assembly不会被单独卸载 如果你需要动态运行环境，你可以创建一个AppDomain，然后在其中加载Assembly并运行，用完之

一、概述在C和C++语言中都有assert关键，表示断言。在Java中，同样也有assert关键字，表示断言，用法和含义都差不多。二、语法在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都 将忽略！），如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。assert关键字语法很简单，有两种用法：1、assert <boolean表达式>如果<boolean表达式>为true，则程序继续执行。如果为false，则程序抛出AssertionError，并终止执行。2、assert <boolean表达式> : <错误信息表达式>如果<boolean表达式>为true，则程序继续执行。如果为false，则程序抛出java.lang.AssertionError，并输入<错误信息表达式>。三、应用实例下面给出一个例子，通过例子说明其用法：复制代码代码如下:public class AssertFoo { public static void main(String args[]) { //断言1结果为true，则继续往下执行 assert true; System.out.println("断言1没有问题，Go！"); System.out.println(" ----------------- "); //断言2结果为false,程序终止 assert false : "断言失败，此表达式的信息将会在抛出异常的时候输出！"; System.out.println("断言2没有问题，Go！"); }}保存代码到C:AssertFoo.java，然后按照下面的方式执行，查看控制台输出结果：1、编译程序：C:>javac AssertFoo.java2、默认执行程序，没有开启-ea开关：C:>java AssertFoo断言1没有问题，Go！-----------------断言2没有问题，Go！3、开启-ea开关，执行程序：C:>java -ea AssertFoo断言1没有问题，Go！-----------------Exception in thread "main" java.lang.AssertionError: 断言失败，此表达式的信息将会在抛出异常的时候输出！ at AssertFoo.main(AssertFoo.java:10)四、陷阱assert关键字用法简单，但是使用assert往往会让你陷入越来越深的陷阱中。应避免使用。笔者经过研究，总结了以下原因：1、assert关键字需要在运行时候显式开启才能生效，否则你的断言就没有任何意义。而现在主流的Java IDE工具默认都没有开启-ea断言检查功能。这就意味着你如果使用IDE工具编码，调试运行时候会有一定的麻烦。并且，对于Java Web应用，程序代码都是部署在容器里面，你没法直接去控制程序的运行，如果一定要开启-ea的开关，则需要更改Web容器的运行配置参数。这对程序的移 植和部署都带来很大的不便。2、用assert代替if是陷阱之二。assert的判断和if语句差不多，但两者的作用有着本质的区别：assert关键字本意上是为测试 调试程序时使用的，但如果不小心用assert来控制了程序的业务流程，那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑。3、assert断言失败将面临程序的退出。这在一个生产环境下的应用是绝不能容忍的。一般都是通过异常处理来解决程序中潜在的错误。但是使用断言就很危险，一旦失败系统就挂了。五、对assert的思考assert既然是为了调试测试程序用，不在正式生产环境下用，那应该考虑更好的测试JUint来代替其做用，JUint相对assert关键的所提供的功能是有过之而无不及。当然完全可以通过IDE debug来进行调试测试。在此看来，assert的前途一片昏暗。因此，应当避免在Java中使用assert关键字，除非哪一天Java默认支持开启-ea的开关，这时候可以考虑。对比一下，assert能给你带来多少好处，多少麻烦，这是我们选择是否使用的的原则。============================================================comment：反过来说，在某些开源组件中，比如validator、junit中，判断过程仿佛使用了断言风格，很有可能使用了大量的断言，但笔者在没看源码之前不能确定。如果是开发阶段的简单测试，junit就是一个便捷强悍的工具，没有理由自己写断言而不去用它。============================================================comment：首先可以用在单元测试代码中。junit侵入性是很强的，如果整个工程大量的代码都使用了junit，就难以去掉或者是选择另外一个框架。如果单元测试代码 很多，并且想复用这些单元测试案例，应该选择assert而不是junit，便于使用别的单元测试框架，比如TestNG。同理正式的功能代码根本就不应 该出现Junit，应该使用assert.assert主要适合在基类，框架类，接口类，核心代码类，工具类中。换言之，当你的代码的调用者是另外一个程序员写得业务代码，或者是另外一个子系统时，就很有必要使用它。比如你做了一个快速排序的算法

在C和C++语言中都有assert关键，表示断言。在Java中，同样也有assert关键字，表示断言，用法和含义都差不多。二、语法在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都 将忽略！），如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。assert关键字语法很简单，有两种用法：1、assert <boolean表达式>如果<boolean表达式>为true，则程序继续执行。如果为false，则程序抛出AssertionError，并终止执行。2、assert <boolean表达式> : <错误信息表达式>如果<boolean表达式>为true，则程序继续执行。如果为false，则程序抛出java.lang.AssertionError，并输入<错误信息表达式>。

（一）首先明确： java断言Assert是jdk1.4引入的。jvm 断言默认是关闭的。断言是可以局部开启的，如：父类禁止断言，而子类开启断言，所以一般说“断言不具有继承性”。 断言只适用于复杂的调试过程。断言一般用于程序执行结果的判断，千万不要让断言处理业务流程。（二）判断eclipse是否开启了断言，代码如下：public class AssertTest { public static void main(String[] args) { boolean isOpen = false; assert isOpen=true; //如果开启了断言，会将isOpen的值改为true System.out.println(isOpen);//打印是否开启了断言 }}执行上面代码，如果打印 true说明已经启用了断言，如果为 false 则没有启用断言。如果没有启用断言，则按按照下面方法开启断言。（三）eclipse中开启断言选择菜单：Run ---> Run... ---> 选择 Arguments 选项卡在 VM arguments 文本框中输入： -ea 注意 中间没有空格，如果输入 -da 表示禁止断言。然后关闭该窗口，提示保存，然后保存就开启了断言。如下图：再次执行第二步操作，如果打印true，说明开启断言成功。如果禁止断言，则按第二步操作中，删除 -ea 或者将 -ea 改为 -da 即可。（四）断言使用第 1 种使用方法：public static void main(String[] args) { boolean isOk = 1>2; assert isOk; System.out.println("程序正常");}因为 1>2 显然是错误的，所以执行结果抛出异常：Exception in thread "main" java.lang.AssertionError如果把 1>2 改为 1<2 则程序能顺利执行，打印 “程序正常”第 2 种使用方法：public static void main(String[] args) { boolean isOk = 1>2; try{ assert isOk : "程序错误"; System.out.println("程序正常"); }catch(AssertionError err){ System.out.println(err.getMessage()); }}assert 后面跟个冒号表达式。如果冒号前为 true，则冒号后面的被忽略。如果冒号前为false，则抛出AssertionError ， 错误信息内容为冒号后面的内容，上面程序执行结果就是打印："程序错误"（五）有关断言的更多参数：-ea java -ea 打开所有用户类的assertion -da java -da 关闭所有用户类的assertion -ea:<classname> java -ea:MyClass1 打开MyClass1的assertion -da:<classname> java -da: MyClass1 关闭MyClass1的assertion -ea:<packagename> java -ea:pkg1 打开pkg1包的assertion -da:<packagename> java -da:pkg1 关闭pkg1包的assertion -ea:... java -ea:... 打开缺省包(无名包)的assertion -da:... java -da:... 关闭缺省包(无名包)的assertion -ea:<packagename>... java -ea:pkg1... 打开pkg1包和其子包的assertion -da:<packagename>... java -da:pkg1... 关闭pkg1包和其子包的assertion -esa java -esa 打开系统类的assertion -dsa java -dsa 关闭系统类的assertion 综合使用 java -dsa:MyClass1:pkg1 关闭MyClass1和pkg1包的assertion

断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 Assertionerror。它用于调试目的： assert(a > 0); // throws an Assertionerror if a <= 0 断言可以有两种形式： assert Expression1 ; assert Expression1 : Expression2 ; Expression1 应该总是产生一个布尔值。 Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。 断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记： javac -source 1.4 Test.java 要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。 要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。 要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。 可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

断言一般用于程序不准备通过捕获异常来处理的错误。对于断言语句：assertnum<=0;如果表达式num<=0的值为真，程序继续执行，否则程序立马结束执行。另外注意：调试程序的时候可以使用如下语句开启断言java-ea例子名称拒绝抄袭、拒绝复制，希望能帮到你！

通俗讲就是在程序某处断定某值，比如f(SomeClass a){assert(a != null);//判断此时对象a是不是等于null，不等于null就不管继续执行；等于貌似就给出提示，这个可以防止下面调用a时出现nullpointException，调试时用......}

通俗讲就是在程序某处断定某值，比如f(SomeClass a){assert(a != null);//判断此时对象a是不是等于null，不等于null就不管继续执行；等于貌似就给出提示，这个可以防止下面调用a时出现nullpointException，调试时用......}

assert翻译过来就是断点， 就是在一个程序里面加一个断点，可以测试自己的项目 ，下面给你看一个简单的列子：x0dx0ax0dx0apublic class AssertExampleOne{x0dx0ax0dx0a public AssertExampleOne(){}x0dx0ax0dx0a public static void main(String args[]){x0dx0ax0dx0a int x=10;x0dx0ax0dx0a System.out.println("Testing Assertion that x==100");x0dx0ax0dx0a assert x==100:"Out assertion failed!";x0dx0ax0dx0a System.out.println("Test passed!");x0dx0ax0dx0a }x0dx0ax0dx0a}x0dx0ax0dx0a在执行时未加 -ea 时输出为x0dx0aTesting Assertion that x==100x0dx0aTest passedx0dx0ajre忽略了断言的就代码，而使用了该参数就会输出为x0dx0aTesting Assertion that x==100x0dx0aException in thread "main" java.lang.AssertionError: Out assertion failed!x0dx0aat AssertExampleOne.main(AssertExampleOne.java:6)x0dx0a断言的副作用x0dx0a由于程序员的问题，断言的使用可能会带来副作用 ，例如：x0dx0aboolean isEnable=false;x0dx0a//...x0dx0a　　assert isEnable=true;

不知道

assigned英-[u0259u02c8sau026and]美-[u0259"sau026and]释义v. 分配（assign的过去分词）；指定；委派adj. 指定的；已分配的

public String insertJCSP(Map parmaters) {// TODO Auto-generated method stubString str=null;Connection conn = null;CallableStatement csm = null;conn = (Connection) sqlSession.getSqlSessionFactory().openSession().getConnection();try {csm = conn.prepareCall("{Call pr_insert_JcInfo(?,?,?)}"); //调用存储过程csm.setString(1, (String) parmaters.get("lottId")); //第一个入参数csm.setString(2, (String) parmaters.get("idata"));//第二个入参数csm.registerOutParameter(3, java.sql.Types.VARCHAR);//返回参数csm.execute();str = csm.getString(3); //取得返回参数

atomic 类已经实现了CAS 算法，不需要加 volatile关键字

　　 一 何谓Atomic? 　　Atomic一词跟原子有点关系 后者曾被人认为是最小物质的单位 计算机中的Atomic是指不能分割成若干部分的意思 如果一段代码被认为是Atomic 则表示这段代码在执行过程中 是不能被中断的 通常来说 原子指令由硬件提供 供软件来实现原子方法（某个线程进入该方法后 就不会被中断 直到其执行完成） 　　在x 平台上 CPU提供了在指令执行期间对总线加锁的手段 CPU芯片上有一条引线#HLOCK pin 如果汇编语言的程序中在一条指令前面加上前缀 LOCK 经过汇编以后的机器代码就使CPU在执行这条指令的时候把#HLOCK pin的电位拉低 持续到这条指令结束时放开 从而把总线锁住 这样同一总线上别的CPU就暂时不能通过总线访问内存了 保证了这条指令在多处理器环境中的原子性 　　 二 ncurrent中的原子变量 　　无论是直接的还是间接的 几乎 ncurrent 包中的所有类都使用原子变量 而不使用同步 类似 ConcurrentLinkedQueue 的类也使用原子变量直接实现无等待算法 而类似 ConcurrentHashMap 的类使用 ReentrantLock 在需要时进行锁定 然后 ReentrantLock 使用原子变量来维护等待锁定的线程队列 　　如果没有 JDK 中的 JVM 改进 将无法构造这些类 这些改进暴露了（向类库 而不是用户类）接口来访问硬件级的同步原语 然后 ncurrent 中的原子变量类和其他类向用户类公开这些功能 　　ncurrent atomic的原子类 　　这个包里面提供了一组原子类 其基本的特性就是在多线程环境下 当有多个线程同时执行这些类的实例包含的方法时 具有排他性 即当某个线程进入方法 执行其中的指令时 不会被其他线程打断 而别的线程就像自旋锁一样 一直等到该方法执行完成 才由JVM从等待队列中选择一个另一个线程进入 这只是一种逻辑上的理解 实际上是借助硬件的相关指令来实现的 不会阻塞线程（或者说只是在硬件级别上阻塞了） 其中的类可以分成 组 　　AtomicBoolean AtomicInteger AtomicLong AtomicReference 　　AtomicIntegerArray AtomicLongArray 　　AtomicLongFieldUpdater AtomicIntegerFieldUpdater AtomicReferenceFieldUpdater 　　AtomicMarkableReference AtomicStampedReference AtomicReferenceArray 　　其中AtomicBoolean AtomicInteger AtomicLong AtomicReference是类似的 　　首先AtomicBoolean AtomicInteger AtomicLong AtomicReference内部api是类似的 举个AtomicReference的例子 　　使用AtomicReference创建线程安全的堆栈 　　Java代码 　　public class LinkedStack<T> { 　　private AtomicReference<Node<T》 stacks = new AtomicReference<Node<T》（） 　　public T push（T e） { 　　Node<T> oldNode newNode; 　　while （true） { //这里的处理非常的特别 也是必须如此的 　　oldNode = stacks get（） 　　newNode = new Node<T>（e oldNode） 　　if （pareAndSet（oldNode newNode）） { 　　return e; 　　} 　　} 　　} 　　public T pop（） { 　　Node<T> oldNode newNode; 　　while （true） { 　　oldNode = stacks get（） 　　newNode = oldNode next; 　　if （pareAndSet（oldNode newNode）） { 　　return oldNode object; 　　} 　　} 　　} 　　private static final class Node<T> { 　　private T object; 　　private Node<T> next; 　　private Node（T object Node<T> next） { 　　this object = object; 　　this next = next; 　　} 　　} 　　} 　　然后关注字段的原子更新 　　AtomicIntegerFieldUpdater<T>/AtomicLongFieldUpdater<T>/AtomicReferenceFieldUpdater<T V>是基于反射的原子更新字段的值 　　相应的API也是非常简 　　单的 但是也是有一些约束的 　　（ ）字段必须是volatile类型的！volatile到底是个什么东西 请查看 　　（ ）字段的描述类型（修饰符public/protected/default/private）是与调用者与操作对象字段的关系一致 也就是说调用者能够直接操作对象字段 那么就可以反射进行原子操作 但是对于父类的字段 子类是不能直接操作的 尽管子类可以访问父类的字段 　　（ ）只能是实例变量 不能是类变量 也就是说不能加static关键字 　　（ ）只能是可修改变量 不能使final变量 因为final的语义就是不可修改 实际上final的语义和volatile是有冲突的 这两个关键字不能同时存在 　　（ ）对于AtomicIntegerFieldUpdater和AtomicLongFieldUpdater只能修改int/long类型的字段 不能修改其包装类型（Integer/Long） 如果要修改包装类型就需要使用AtomicReferenceFieldUpdater 　　在下面的例子中描述了操作的方法 　　[java] 　　import ncurrent atomic AtomicIntegerFieldUpdater; 　　public class AtomicIntegerFieldUpdaterDemo { 　　class DemoData{ 　　public volatile int value = ; 　　volatile int value = ; 　　protected volatile int value = ; 　　private volatile int value = ; 　　} 　　AtomicIntegerFieldUpdater<DemoData> getUpdater（String fieldName） { 　　return AtomicIntegerFieldUpdater newUpdater（DemoData class fieldName） 　　} 　　void doit（） { 　　DemoData data = new DemoData（） 　　System out println（ ==> +getUpdater（ value ） getAndSet（data ）） 　　System out println（ ==> +getUpdater（ value ） incrementAndGet（data）） 　　System out println（ ==> +getUpdater（ value ） decrementAndGet（data）） 　　System out println（ true ==> +getUpdater（ value ） pareAndSet（data ）） 　　} 　　public static void main（String[] args） { 　　AtomicIntegerFieldUpdaterDemo demo = new AtomicIntegerFieldUpdaterDemo（） 　　demo doit（） 　　} 　　} 　　在上面的例子中DemoData的字段value /value 对于AtomicIntegerFieldUpdaterDemo类是不可见的 因此通过反射是不能直接修改其值的 　　AtomicMarkableReference类描述的一个<Object Boolean>的对 可以原子的修改Object或者Boolean的值 这种数据结构在一些缓存或者状态描述中比较有用 这种结构在单个或者同时修改Object/Boolean的时候能够有效的提高吞吐量 　　AtomicStampedReference类维护带有整数 标志 的对象引用 可以用原子方式对其进行更新 对比AtomicMarkableReference类的<Object Boolean> AtomicStampedReference维护的是一种类似<Object int>的数据结构 其实就是对对象（引用）的一个并发计数 但是与AtomicInteger不同的是 此数据结构可以携带一个对象引用（Object） 并且能够对此对象和计数同时进行原子操作 　　在本文结尾会提到 ABA问题 而AtomicMarkableReference/AtomicStampedReference在解决 ABA问题 上很有用 　　 三 Atomic类的作用 　　使得让对单一数据的操作 实现了原子化 　　使用Atomic类构建复杂的 无需阻塞的代码 　　访问对 个或 个以上的atomic变量（或者对单个atomic变量进行 次或 次以上的操作）通常认为是需要同步的 以达到让这些操作能被作为一个原子单元 　　 无锁定且无等待算法 　　基于 CAS （pare and swap）的并发算法称为 无锁定算法 因为线程不必再等待锁定（有时称为互斥或关键部分 这取决于线程平台的术语） 无论 CAS 操作成功还是失败 在任何一种情况中 它都在可预知的时间内完成 如果 CAS 失败 调用者可以重试 CAS 操作或采取其他适合的操作 　　如果每个线程在其他线程任意延迟（或甚至失败）时都将持续进行操作 就可以说该算法是 无等待的 与此形成对比的是 无锁定算法要求仅 某个线程总是执行操作 （无等待的另一种定义是保证每个线程在其有限的步骤中正确计算自己的操作 而不管其他线程的操作 计时 交叉或速度 这一限制可以是系统中线程数的函数 例如 如果有 个线程 每个线程都执行一次CasCounter increment（） 操作 最坏的情况下 每个线程将必须重试最多九次 才能完成增加 ） 　　再过去的 年里 人们已经对无等待且无锁定算法（也称为 无阻塞算法）进行了大量研究 许多人通用数据结构已经发现了无阻塞算法 无阻塞算法被广泛用于操作系统和 JVM 级别 进行诸如线程和进程调度等任务 虽然它们的实现比较复杂 但相对于基于锁定的备选算法 它们有许多优点 可以避免优先级倒置和死锁等危险 竞争比较便宜 协调发生在更细的粒度级别 允许更高程度的并行机制等等 　　 常见的 　　非阻塞的计数器Counter 　　非阻塞堆栈ConcurrentStack lishixinzhi/Article/program/Java/gj/201311/27474

print为不换行输出；println为换行输出

import java.text.SimpleDateFormat;import java.util.Date;/** * 问题模拟，解决方案 to 匿名 * 只是一个模拟，希望你能从中获得一些想法 *copy到IDE中会好分析一些 * @author Administrator * */public class WorkeSimulation { public static void main(String[] args) { // 1、扫描指纹 获得 员工信息 // 2、判断该员工改日是否签到、签离 // 3、写入记录 /** 下方为过程的模拟 **/ String 工作号 = "BJ-TNFCP-08001002"; String 姓名 = "JIAQIANLI.CN@GMAIL.COM"; WorkeSimulation simulation = new WorkeSimulation(); simulation.早上打卡(姓名, 工作号); } public void 早上打卡(String 姓名, String 工作号) { // 查询数据库今天是否签到 Date nowtime = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); String timestr = sdf.format(nowtime); String sql = "select * from worke_record where 工作号="" + 工作号 + """; sql += " where record_type=" + Type.START_WORKE + " and record_time like "" + timestr + "%""; boolean already = verify(sql); if (already) return; TimeCardRecord record = new TimeCardRecord(); record.setName(姓名); record.setWorkerNumber(工作号); record.setType(Type.START_WORKE); record.setDate(nowtime); saveRecord(record); } public void 下午打卡(String 姓名, String 工作号) { // 查询数据库今天是否签离 Date nowtime = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); String timestr = sdf.format(nowtime); String sql = "select * from worke_record where 工作号="" + 工作号 + """; sql += " where record_type=" + Type.FINISHED_WORKE + " and record_time like "" + timestr + "%""; boolean already = verify(sql); if (already) return; TimeCardRecord record = new TimeCardRecord(); record.setName(姓名); record.setWorkerNumber(工作号); record.setType(Type.FINISHED_WORKE); record.setDate(nowtime); saveRecord(record); } private void saveRecord(TimeCardRecord record) { // TODO 编写数据库插入 } /** * 验证是否数据库存在此条数据 * @param sql * @return */ private boolean verify(String sql) { boolean flag = true; // 自己实现 数据查询 并确定flag真假 然后返回 return flag; } /** * 打卡记录类 * @author Administrator * */ class TimeCardRecord { /** 打卡类型*/ private Type type; /** 日期*/ private Date date; /** 员工姓名*/ private String name; /** 工号*/ private String workerNumber; public Type getType() { return type; } public void setType(Type type) { this.type = type; } public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getWorkerNumber() { return workerNumber; } public void setWorkerNumber(String workerNumber) { this.workerNumber = workerNumber; } } /** * 打卡类型枚举 * @author Administrator * */ enum Type { START_WORKE(1), FINISHED_WORKE(2); private final int FLAG; private Type(int flag) { this.FLAG = flag; } @Override public String toString() { return "" + FLAG; } }}

cst.registerOutParameter(2, Types.DOUBLE);