java

match()的参数一般为正则表达式，现在两个正则表达式，可以试用正则表达式一：可以适用任何形式的字符串，其中LikeType是要匹配的字符串，patten是生成的正则表达式，sourceStr是已有字符串，判断sourceStr是否满足LikeType的正则表达式public static void main(String[] args) {// TODO Auto-generated method stubString likeType = "23";String pattern = "[a-zA-Z0-9]*[" + likeType + "]{1}[a-zA-Z0-9]*";String sourceStr = "adfjaslfj23ldfalsf";System.out.println(sourceStr.matches(likeType));}正则表达式二：固定位置的字符串匹配,理解同上，只是正则表达式的不同public static void main(String[] args) {// TODO Auto-generated method stubString likeType = "%%%23%%%*";String sourceStr = "423236664";likeType = likeType.replaceAll("%", "\\d").replaceAll("\*", "\\d\*");System.out.println(likeType);System.out.println(sourceStr.matches(likeType));}match的方法比较简单，但绝对实用，所以要掌握用法，正则表达式的写法尤其重要。

java.util.regex.Matcherpublic class TestRegex { public static void main(String[] args) { String str = "abdsfsf123sfsfs232df"; Pattern pattern = Pattern.compile("\d+"); Matcher matcher = pattern.matcher(str); while(matcher.find()) { System.out.println(matcher.group()); } }}

匹配1~10个英文字母

？

stack 区存放函数参数和局部变量；heap 区存放对象；data 区存放static 的变量或者字符串常量；code 区存放类中的方法；stack 栈 -->放方法的参数 和局部变量.就像这样----------- void test(String[] args){ int xx = 0;// args和 xx在jvm load class时存放在栈中 }heap 堆 --> 堆要比栈要大得多. 当一个对象对new出来时,该对象放在heap中,对象引用放在栈中.data区,也就是数据区 -->静态的变量 和 string的常量.code 代码区 --->classloader类加载器加载该class时存放类中的方法.

java堆内存大小

个人理解:java 代码申请的内存空间在java heap中。使用到的本地的C/C++ API时，则C/C++API 申请的内存就在native heap也就是c-heap。

栈是存放函数调用过程中的临时变量的！ 堆是程序运行过程中动态申请的内存的存放处的！比如new的对象就在堆上在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的. 静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.栈式存储分配也可称为动态存储分配,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配。从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.

　　当我开始学习Java编程时 我不知道什么是堆内存或堆空间 我甚至不知道当对象创建时 它们被放在了哪里 当我开始正式写一些程序后 我会经常遇到java lang outOfMemoryError的报错 之后我才开始关注什么是堆内存或者说堆空间（heap space） 对大多数程序员都经历过这样的过程 因为学习一种语言是非常容易来的 但是学习基础是非常难的 因为没有什么特定的流程让你学习编程的每个基础 使你发觉编程的秘诀 　　对于程序员来说 知道堆空间 设置堆空间 处理堆空间的outOfMemoryError错误 分析heap dump是非常重要的 这个关于Java堆的教程是给我刚开始学编程的兄弟看的 如果你知道这个基础知识或者知道底层发生了什么 当然可能帮助不是那么大 除非你知道了对象被创建在堆中 否则你不会意识到OutOfMemoryError是发生在堆空间中的 我尽可能的将我所知道的所有关于堆的知识都写下来了 也希望你们能够尽可能多的贡献和分享你的知识 以便可以让其他人也受益 　　Java中的堆空间是什么？ 　　当Java程序开始运行时 JVM会从操作系统获取一些内存 JVM使用这些内存 这些内存的一部分就是堆内存 堆内存通常在存储地址的底层 向上排列 当一个对象通过new关键字或通过其他方式创建后 对象从堆中获得内存 当对象不再使用了 被当做垃圾回收掉后 这些内存又重新回到堆内存中 要学习垃圾回收 请阅读 Java中垃圾回收的工作原理 　　如何增加Java堆空间 　　在大多数 位机 Sun的JVM上 Java的堆空间默认的大小为 MB 但也有例外 例如在 未Solaris操作系统（SPARC平台版本）上 默认的最大堆空间和起始堆空间大小为 Xms= K 和 Xmx= M 对于 位操作系统 一般堆空间大小增加约 % 但你使用Java 的throughput垃圾回收器 默认最大的堆大小为物理内存的四分之一 而起始堆大小为物理内存的十六分之一 要想知道默认的堆大小的方法 可以用默认的设置参数打开一个程序 使用JConsole（JDK 之后都支持）来查看 在VM Summary页面可以看到最大的堆大小 　　用这种方法你可以根据你的程序的需要来改变堆内存大小 我强烈建议采用这种方法而不是默认值 如果你的程序很大 有很多对象需要被创建的话 你可以用 Xms and Xmx这两个参数来改变堆内存的大小 Xms表示起始的堆内存大小 Xmx表示最大的堆内存的大小 另外有一个参数 Xmn 它表示new generation（后面会提到）的大小 有一件事你需要注意 你不能任意改变堆内存的大小 你只能在启动JVM时设定它 　　堆和垃圾回收 　　我们知道对象创建在堆内存中 垃圾回收这样一个进程 它将已死对象清除出堆空间 并将这些内存再还给堆 为了给垃圾回收器使用 堆主要分成三个区域 分别叫作New Generation Old Generation或叫Tenured Generation 以及Perm space New Generation是用来存放新建的对象的空间 在对象新建的时候被使用 如果长时间还使用的话 它们会被垃圾回收器移动到Old Generation（或叫Tenured Generation） Perm space是JVM存放Meta数据的地方 例如类 方法 字符串池和类级别的详细信息 你可以查看 Java中垃圾回收的工作原理 来获得更多关于堆和垃圾回收的信息 　　Java堆中的OutOfMemoryError错误 　　当JVM启动时 使用了 Xms 参数设置的对内存 当程序继续进行 创建更多对象 JVM开始扩大堆内存以容纳更多对象 JVM也会使用垃圾回收器来回收内存 当快达到 Xmx设置的最大堆内存时 如果没有更多的内存可被分配给新对象的话 JVM就会抛出java lang outofmemoryerror 你的程序就会当掉 在抛出 OutOfMemoryError之前 JVM会尝试着用垃圾回收器来释放足够的空间 但是发现仍旧没有足够的空间时 就会抛出这个错误 为了解决这个问题 你需要清楚你的程序对象的信息 例如 你创建了哪些对象 哪些对象占用了多少空间等等 你可以使用profiler或者堆分析器来处理 OutOfMemoryError错误 java lang OutOfMemoryError Java heap space 表示堆没有足够的空间了 不能继续扩大了 java lang OutOfMemoryError PermGen space 表示permanent generation已经装满了 你的程序不能再装在类或者再分配一个字符串了 　　Java Heap dump 　　Heap dump是在某一时间对Java堆内存的快照 它对于分析堆内存或处理内存泄露和Java lang outofmemoryerror错误是非常有用的 在JDK中有一些工具可以帮你获取heap dump 也有一些堆分析工具来帮你分析heap dump 你可以用 jmap 来获取heap dump 它帮你创建heap dump文件 然后 你可以用 jhat （堆分析工具）来分析这些heap dump 　　Java堆内存（heap memory）的十个要点 　　 Java堆内存是操作系统分配给JVM的内存的一部分 　　 当我们创建对象时 它们存储在Java堆内存中 　　 为了便于垃圾回收 Java堆空间分成三个区域 分别叫作New Generation Old Generation或叫作Tenured Generation 还有Perm Space 　　 你可以通过用JVM的命令行选项 Xms Xmx Xmn来调整Java堆空间的大小 不要忘了在大小后面加上 M 或者 G 来表示单位 举个例子 你可以用 Xmx m来设置堆内存最大的大小为 MB 　　 你可以用JConsole或者 Runtime maxMemory（） Runtime totalMemory（） Runtime freeMemory（）来查看Java中堆内存的大小 　　 你可以使用命令 jmap 来获得heap dump 用 jhat 来分析heap dump 　　 Java堆空间不同于栈空间 栈空间是用来储存调用栈和局部变量的 　　 Java垃圾回收器是用来将死掉的对象（不再使用的对象）所占用的内存回收回来 再释放到Java堆空间中 　　 当你遇到java lang outOfMemoryError时 不要紧张 有时候仅仅增加堆空间就可以了 但如果经常出现的话 就要看看Java程序中是不是存在内存泄露了 lishixinzhi/Article/program/Java/hx/201311/26778

jvm有自己的垃圾回收机制，可以自动回收的，万一不行 重新装一下jdk啊

eclipse修改heap size:用eclipse 开发，在用ant编译我的web工程时，碰到java.lang.OutOfMemoryError: Java heap space异常。解决办法：1.window->preferences->java->installed jres->edit jre把default vm arguments 的参数设为-Xms64m -Xmx512方法2。在window的环境变量中添加JAVA_OPTS=-Xms64m -Xmx512m

在java虚拟机未运行的情况下进入cmd，运行以下命令,其中的*号替换成你想要设置的数值java -Xms***m -Xmx***m

　　在JVM中 内存分为两个部分 Stack(栈)和Heap(堆) 这里 我们从JVM的内存管理原理的角度来认识Stack和Heap 并通过这些原理认清Java中静态方法和静态属性的问题 　　一般 JVM的内存分为两部分 Stack和Heap 　　Stack(栈)是JVM的内存指令区 Stack管理很简单 push一定长度字节的数据或者指令 Stack指针压栈相应的字节位移;pop一定字节长度数据或者指令 Stack指针弹栈 Stack的速度很快 管理很简单 并且每次操作的数据或者指令字节长度是已知的 所以Java 基本数据类型 Java 指令代码 常量都保存在Stack中 　　Heap(堆)是JVM的内存数据区 Heap 的管理很复杂 每次分配不定长的内存空间 专门用来保存对象的实例 在Heap 中分配一定的内存来保存对象实例 实际上也只是保存对象实例的属性值 属性的类型和对象本身的类型标记等 并不保存对象的方法(方法是指令 保存在Stack中) 在Heap 中分配一定的内存保存对象实例和对象的序列化比较类似 而对象实例在Heap 中分配好以后 需要在Stack中保存一个 字节的Heap 内存地址 用来定位该对象实例在Heap 中的位置 便于找到该对象实例 　　由于Stack的内存管理是顺序分配的 而且定长 不存在内存回收问题;而Heap 则是随机分配内存 不定长度 存在内存分配和回收的问题;因此在JVM中另有一个GC进程 定期扫描Heap 它根据Stack中保存的 字节对象地址扫描Heap 定位Heap 中这些对象 进行一些优化(例如合并空闲内存块什么的) 并且假设Heap 中没有扫描到的区域都是空闲的 统统refresh(实际上是把Stack中丢失了对象地址的无用对象清除了) 这就是垃圾收集的过程;关于垃圾收集的更深入讲解请参考 CTO之前的文章《JVM内存模型及垃圾收集策略解析》 　　 　　 JVM的体系结构 　　我们首先要搞清楚的是什么是数据以及什么是指令 然后要搞清楚对象的方法和对象的属性分别保存在哪里 　　 )方法本身是指令的操作码部分 保存在Stack中; 　　 )方法内部变量作为指令的操作数部分 跟在指令的操作码之后 保存在Stack中(实际上是简单类型保存在Stack中 对象类型在Stack中保存地址 在Heap 中保存值);上述的指令操作码和指令操作数构成了完整的Java 指令 　　 )对象实例包括其属性值作为数据 保存在数据区Heap 中 　　非静态的对象属性作为对象实例的一部分保存在Heap 中 而对象实例必须通过Stack中保存的地址指针才能访问到 因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针 　　 非静态方法和静态方法的区别 　　非静态方法有一个和静态方法很重大的不同 非静态方法有一个隐含的传入参数 该参数是JVM给它的 和我们怎么写代码无关 这个隐含的参数就是对象实例在Stack中的地址指针 因此非静态方法(在Stack中的指令代码)总是可以找到自己的专用数据(在Heap 中的对象属性值) 当然非静态方法也必须获得该隐含参数 因此非静态方法在调用前 必须先new一个对象实例 获得Stack中的地址指针 否则JVM将无法将隐含参数传给非静态方法 　　静态方法无此隐含参数 因此也不需要new对象 只要class文件被ClassLoader load进入JVM的Stack 该静态方法即可被调用 当然此时静态方法是存取不到Heap 中的对象属性的 　　总结一下该过程 当一个class文件被ClassLoader load进入JVM后 方法指令保存在Stack中 此时Heap 区没有数据 然后程序技术器开始执行指令 如果是静态方法 直接依次执行指令代码 当然此时指令代码是不能访问Heap 数据区的;如果是非静态方法 由于隐含参数没有值 会报错 因此在非静态方法执行前 要先new对象 在Heap 中分配数据 并把Stack中的地址指针交给非静态方法 这样程序技术器依次执行指令 而指令代码此时能够访问到Heap 数据区了 　　 静态属性和动态属性 　　前面提到对象实例以及动态属性都是保存在Heap 中的 而Heap 必须通过Stack中的地址指针才能够被指令(类的方法)访问到 因此可以推断出 静态属性是保存在Stack中的 而不同于动态属性保存在Heap 中 正因为都是在Stack中 而Stack中指令和数据都是定长的 因此很容易算出偏移量 也因此不管什么指令(类的方法) 都可以访问到类的静态属性 也正因为静态属性被保存在Stack中 所以具有了全局属性 lishixinzhi/Article/program/Java/hx/201311/26460

Math中的min方法是用来比较两个数大小的，比较结果中返回较小的那个数值用法：Math.min(a,b);其中：a，b可接受double、float、int、long四种类型。例子inta=4,b=6;intc=Math.min(a,b);输出结果：4。floata=2.0f,b=3.0f;floatc=Math.min(a,b);输出结果：2.0.

楼主自己的那个解答当然是不对的，在那个函数里只要a[n-1][n-1]==b[n-1][n-1]就会返回true了，这当然不是相等。我觉得是这样：static boolean judge(int a[][], int b[][], int n){ int i, j; for(i = 0; i < n; ++i) for(j = 0; j < n; ++j) if(a[i][j] != b[i][j]) return false; return true;}这样就是说，如果两个矩阵里有任何一个元素不同，那么马上返回false，如果每一个元素都相同，那么在函数最后返回true

public class Gas { public class USER//内部类 { String name;//用户姓名 int m3;//使用煤气的立方米数 String account;//用户账号 //构造函数 public USER(String n,String a){name=n;account=a;} } USER[] users=new USER[1000000];//所有用户 StringBuffer[] bills=new StringBuffer[1000000];//所有用户的账单 //账单模板 String tmplt1="尊敬的U用户：你Y月煤气使用M立方米，单价P元/立方米，总计T元。N-Y—R"; String tmplt2="尊敬的U用户：你Y月煤气使用M立方米，单价P元/立方米，总计T元。R"; int count;//所有用户数 static int price;//煤气单价 //构造函数 public Gas(int p){price=p;count=0;} //输入一个用户 public void input_user(String n,String a) { users[count++]=new USER(n,a); } //输入用户煤气立方米数 public void input_m3(int i,int m) { users[i].m3=m; } //用于定位模板中要被替换数据的下标 static int[] pos=new int[]{3,8,14,21,30,33,35,37}; static final int U=3,Y=8,M=14,P=21,T=30,R=33; //第一个填写账单的方法 void create_bills1(int n,int y,int r) { StringBuffer b; for(int i=0;i<count;i++) { b=new StringBuffer(tmplt1); b.replace(37,38,r+""); b.replace(35,36,y+""); b.replace(33,34,n+""); b.replace(30,31,price*users[i].m3+""); b.replace(21,22,price+""); b.replace(14,15,users[i].m3+""); b.replace(8,9,(y-1)+""); b.replace(3,4,users[i].name+""); bills[i]=b; } } //第二个填写账单的方法，使用常量定位 void create_bills2(int n,int y,int r) { StringBuffer b; String nyr=n+"-"+y+"-"+r; for(int i=0;i<count;i++) { b=new StringBuffer(tmplt2); b.replace(R,R+1,nyr); b.replace(T,T+1,price*users[i].m3+""); b.replace(P,P+1,price+""); b.replace(M,M+1,users[i].m3+""); b.replace(Y,Y+1,(y-1)+""); b.replace(U,U+1,users[i].name+""); bills[i]=b; } } //打印账单 public void print_bills() { for(int i=0;i<count;i++) System.out.println(bills[i]); } public static void main(String[]args) { Gas g=new Gas(12); //输入三个用户 g.input_user("aaa", "123"); g.input_user("bbb", "124"); g.input_user("ccc", "125"); //输入煤气用量 g.input_m3(0, 100); g.input_m3(1, 150); g.input_m3(2, 200); //生成账单 g.create_bills2(2012, 4, 12); //打印账单 g.print_bills(); }}

java中judge()在循环语句中的的用法static boolean judge(int a[][], int b[][], int n){int i, j;boolean bl = false;for(i = 0; i < n; ++i)for(j = 0; j < n; ++j)。//注意到调用 judge时只有两个参数static boolean judge(int a[][], int b[][]){if(a.length != b.length) {//判断 a b长度是不是一致的return false;}int i, j;int n = a.length;for(i = 0; i < n; ++i){if(a[i].length != b[i].length) {//判断每列长度是不是一致的。安全性：Java的存储分配模型是它防御恶意代码的主要方法之一。Java没有指针，所以程序员不能得到隐蔽起来的内幕和伪造指针去指向存储器。更重要的是，Java编译程序不处理存储安排决策，所以程序员不能通过查看声明去猜测类的实际存储安排。编译的Java代码中的存储引用在运行时由Java解释程序决定实际存储地址。Java运行系统使用字节码验证过程来保证装载到网络上的代码不违背任何Java语言限制。这个安全机制部分包括类如何从网上装载。例如，装载的类是放在分开的名字空间而不是局部类，预防恶意的小应用程序用它自己的版本来代替标准Java类。

括号里的东西就是你要操作的内容呀，一个操作的逻辑，一串代码当然了，这个东西对所有试图访问它的人来说是共有的，同时只允许一个人去做举个很简单的例子，有一个打印机，同时好几个人想去用它synchronized{applyPrinter(); // 申请使用打印机}当然了，也可以把这个方法声明为synchronized的 synchronized void applyPrinter();也可以用Lock去做

这个synchronized也可以放在方法头部声明的。synchronized线程并发机制吧

那是因为你插入的数据来源具有随机性。意思是说，你插入数据库中的nocode是从同一张表读取的，并做截取+1,有重复一点也不奇怪。

synchronized 是java保留的关键字，不在那个具体的类中。

传的是this 么？ 。。同一个.java 文件里应该没区别。。如果有多个class 。。 其中有个class是负责同步线程的，那么，这个参数就是需要被同步的对象吧 。。。这个是我的理解

synchronized是对象锁,而不是方法.obj是Object的一个实例,相当于一个标示.synchronized (obj){ if (index > 0){ try{ Thread.sleep(10); System.out.println(Thread.currentThread() .getName() + "卖了第" + index + "张饭票"); index--; }catch(InterruptedException e){ e.printStackTrace(); } }}这段代码的意思是说被synchronized (obj){ }包围的代码是同步的,同一时间内只能由一个线程使用.

synchronized是同步关键字, 表示线程安全的.serializable 接口是启用其序列化功能的接口。 表示类可以系列化.

如果多个线程在同一时刻访问时就会出现意外。

首先synchronized不可能做到对某条数据库的数据加锁。它能做到的只是对象锁。比如数据表table_a中coloum_b的数据是临界数据，也就是你说的要保持一致的数据。你可以定义一个类，该类中定义两个方法read()和write()(注意，所有有关该临界资源的操作都定义在这个类中)，再定义一个静态变量作为锁就可以了。publicstaticfinalstringlock="table_a_b_lock";publicintread(){synchronizedlock{system.out.println("readdata...");}}publicvoidwrite(stringdata){synchronizedlock{system.out.println("writedata:"+data);}}另外，还可以在数据库级别加上锁。数据库本来就支持不同的隔离级别。

度君正解

首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。详细说明如下： synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用。示例代码：public class Thread1 implements Runnable { public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); } } } public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread ta = new Thread(t1, "A"); Thread tb = new Thread(t1, "B"); ta.start(); tb.start(); }}结果： A synchronized loop 0 A synchronized loop 1 A synchronized loop 2 A synchronized loop 3 A synchronized loop 4 B synchronized loop 0 B synchronized loop 1 B synchronized loop 2 B synchronized loop 3 B synchronized loop 4

你知道synchronized是起什么作用的吗？你知道run()在什么时候被调用吗？

首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。x0dx0ax0dx0a详细说明如下：x0dx0ax0dx0a synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。x0dx0a 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。x0dx0a 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。x0dx0a 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。x0dx0a 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。x0dx0a 五、以上规则对其它对象锁同样适用。x0dx0ax0dx0a示例代码：x0dx0apublic class Thread1 implements Runnable { x0dx0a public void run() { x0dx0a synchronized(this) { x0dx0a for (int i = 0; i < 5; i++) { x0dx0a System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); x0dx0a } x0dx0a } x0dx0a } x0dx0a public static void main(String[] args) { x0dx0a Thread1 t1 = new Thread1(); x0dx0a Thread ta = new Thread(t1, "A"); x0dx0a Thread tb = new Thread(t1, "B"); x0dx0a ta.start(); x0dx0a tb.start(); x0dx0a }x0dx0a}x0dx0a结果： x0dx0a A synchronized loop 0 x0dx0a A synchronized loop 1 x0dx0a A synchronized loop 2 x0dx0a A synchronized loop 3 x0dx0a A synchronized loop 4 x0dx0a B synchronized loop 0 x0dx0a B synchronized loop 1 x0dx0a B synchronized loop 2 x0dx0a B synchronized loop 3 x0dx0a B synchronized loop 4

线程锁,即操作一个对象时，加入A正在操作，那么B只能等待A操作完后才能进行操作,在单例模式和多线程中用的蛮多.

synchronized(obj){代码块C}，其实锁的是obj这个对象。比如当多个线程要同时执行代码块C并且obj是同一个对象时，锁发挥作用（在任意时刻最多只有一个线程执行代码块C），注意：前提是obj是同一个对象。如果现在将代码改为synchronized(new Object()){代码块C}，这时将起不到锁的作用，因为每次锁得都是一个新的Object。

synchronized(obj)里的这个obj就是加锁的对象。

java语言的synchronized关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

在java编程思想中对synchronized的一点解释:1、synchronized关键字的作用域有二种：1）是某个对象实例内，synchronizedaMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；2）是某个类的范围，synchronizedstaticaStaticMethod{}防止多个线程同时访问这个类中的synchronizedstatic方法。它可以对类的所有对象实例起作用。

mark!

Java的synchronized加在方法上或者对象上区别如下：1.synchronized在方法上，所有这个类的加了synchronized的方法，在执行时，会获得一个该类的唯一的同步锁，当这个锁被占用时，其他的加了synchronized的方法就必须等待

synchronized，Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。你百度呀..

Java的synchronized可以加在方法上，也可以直接加在对象上，从而保证一段代码只能有一个线程在运行，保证线程的同步。详情请见：http://blog.csdn.net/loveyaqin1990/article/details/41313285

没有唤醒吧。。

synchronized(this)

Thread.sleep操作线程能够将变量的修改同步到主存中。

会同步。。。。

这个参数是指哪个对象是被互斥访问的。

synchronized是java中的一个关键字我们称其为同步关键字主要是用来处理java中的同步机制同一个资源被用户并发访问时，会出现并发问题，比如：有一个实例变量x，第一个用户访问它，并赋值为100，但还没有来得及打印出x，另一个哥们进来访问了x，并改为200，这时候第一个哥们兴高采烈的打印出x的值，但却发现不是100，是200.这哥们就郁闷了，怎么回事呢？这就是并发问题，但如果把上面的代码用同步代码块包含起来，任意一个时间只能有一个哥们访问实例变量x，一直到这哥们执行完同步代码块中的所有代码后，其他哥们才能再访问。

在java语言中，synchronized关键字通常用来修饰语句块或方法。被synchronized关键字修饰的语句块或方法在同一时间内只有一个线程 对象对它进行操作。

java中 synchronized同步处理后，代表该线程是同步的，即多线程访问时，无法同时有两个或以上线程进行访问。具体的原理是，当第一个线程进入该同步代码块之后，会暂时获得同步块的锁，当第二个线程进入时，由于第一个线程并未结束，同步代码块的锁没有释放，所以第二个线程进不来，达到只有一个线程在运行的目的。synchronized同步处理通常用于封装需要共享的可改变的数据，为了让数据更安全所使用的技术。

object是你指定加锁的对象

synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。

synchronized()、synchronized(this)、synchronized(类名.class)synchronized加在非静态方法前和synchronized(this)都是锁住了这个类的对象，如果多线程访问，对象不同，就锁不住，对象固定是一个，就可锁住。synchronized(类名.class)和加在静态方法前，是锁住了代码块，不管多线程访问的时候对象是不是同一个，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步，缩小锁的粒度。

你这样写肯定同步不了。一个对象含有一个隐藏的锁和隐藏的条件，你这样synchronized(newObject()){}这种写法每次都会生成一个新对象，就等于每个线程都能获得这个新对象的锁，所以根本无法做到同步

锁机制，放在修饰符后面

有4种:instance 方法同步、instance 方法中部分程式码同步、static 方法同步、class literals 同步。

wait()会立刻释放synchronized（obj）中的obj锁，以便其他线程可以执行obj.notify()但是notify()不会立刻立刻释放sycronized（obj）中的obj锁，必须要等notify()所在线程执行完synchronized（obj）块中的所有代码才会释放这把锁.yield(),sleep()不会释放锁

一、synchronized和lock的用法区别synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。二、synchronized和lock用途区别synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。1.某个线程在等待一个锁的控制权的这段时间需要中断2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程3.具有公平锁功能，每个到来的线程都将排队等候

synchronized[英]["su026au014bkru0259nau026azd][美]["su026au014bkru0259nau026azd]同步的; 例句:1.What do you mean by incorrectly synchronized? 没有正确同步的含义是什么？2.Head first, united states team members practiced a technical routine at the olympicgames synchronized swimming qualifications in london. 美国国家队成员正倒立水中，为伦敦奥运的花样游泳资格赛进行技术自选训练。

在分布式开发中，锁是线程控制的重要途径。Java为此也提供了2种锁机制，synchronized和lock。做为Java爱好者，自然少不了对比一下这2种机制，也能从中学到些分布式开发需要注意的地方。我们先从最简单的入手，逐步分析这2种的区别。一、synchronized和lock的用法区别synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。用法区别比较简单，这里不赘述了，如果不懂的可以看看Java基本语法。二、synchronized和lock性能区别synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。在Java1.5中，synchronize是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6，发生了变化。synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上synchronize的性能并不比Lock差。官方也表示，他们也更支持synchronize，在未来的版本中还有优化余地。说到这里，还是想提一下这2中机制的具体区别。据我所知，synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。而在CPU转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。而Lock用的是乐观锁方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是CAS操作（Compare and Swap）。我们可以进一步研究ReentrantLock的源代码，会发现其中比较重要的获得锁的一个方法是compareAndSetState。这里其实就是调用的CPU提供的特殊指令。现代的CPU提供了指令，可以自动更新共享数据，而且能够检测到其他线程的干扰，而 compareAndSet() 就用这些代替了锁定。这个算法称作非阻塞算法，意思是一个线程的失败或者挂起不应该影响其他线程的失败或挂起的算法。我也只是了解到这一步，具体到CPU的算法如果感兴趣的读者还可以在查阅下，如果有更好的解释也可以给我留言，我也学习下。三、synchronized和lock用途区别synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。1.某个线程在等待一个锁的控制权的这段时间需要中断2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程3.具有公平锁功能，每个到来的线程都将排队等候下面细细道来……先说第一种情况，ReentrantLock的lock机制有2种，忽略中断锁和响应中断锁，这给我们带来了很大的灵活性。比如：如果A、B2个线程去竞争锁，A线程得到了锁，B线程等待，但是A线程这个时候实在有太多事情要处理，就是一直不返回，B线程可能就会等不及了，想中断自己，不再等待这个锁了，转而处理其他事情。这个时候ReentrantLock就提供了2种机制，第一，B线程中断自己（或者别的线程中断它），但是ReentrantLock不去响应，继续让B线程等待，你再怎么中断，我全当耳边风（synchronized原语就是如此）；第二，B线程中断自己（或者别的线程中断它），ReentrantLock处理了这个中断，并且不再等待这个锁的到来，完全放弃。（如果你没有了解java的中断机制，请参考下相关资料，再回头看这篇文章，80%的人根本没有真正理解什么是java的中断，呵呵）这里来做个试验，首先搞一个Buffer类，它有读操作和写操作，为了不读到脏数据，写和读都需要加锁，我们先用synchronized原语来加锁，如下：1 public class Buffer { 2 3 private Object lock; 4 5 public Buffer() { 6 lock = this; 7 } 8 9 public void write() { 10 synchronized (lock) { 11 long startTime = System.currentTimeMillis(); 12 System.out.println("开始往这个buff写入数据…"); 13 for (;;)// 模拟要处理很长时间 14 { 15 if (System.currentTimeMillis() 16 - startTime > Integer.MAX_VALUE) 17 break; 18 } 19 System.out.println("终于写完了"); 20 } 21 } 22 23 public void read() { 24 synchronized (lock) { 25 System.out.println("从这个buff读数据"); 26 } 27 } 28

java中 synchronized同步处理后，代表该线程是同步的，即多线程访问时，无法同时有两个或以上线程进行访问。具体的原理是，当第一个线程进入该同步代码块之后，会暂时获得同步块的锁，当第二个线程进入时，由于第一个线程并未结束，同步代码块的锁没有释放，所以第二个线程进不来，达到只有一个线程在运行的目的。synchronized同步处理通常用于封装需要共享的可改变的数据，为了让数据更安全所使用的技术。

这个方法，只允许一个线程进入。

参考我以前的回答：Java的synchronized加在方法上或者对象上区别如下：1.synchronized 在方法上，所有这个类的加了 synchronized 的方法，在执行时，会获得一个该类的唯一的同步锁，当这个锁被占用时，其他的加了 synchronized 的方法就必须等待2.加在对象上的话，就是以这个对象为锁，其他也以这个对象为锁的代码段，在这个锁被占用时，就必须等待

synchronized的参数代表的是“对象锁”。sychronized加锁的是对象，而不是代码。举了例子：public class Person{private String name; //意思差不多就是你那个objpublic setName(String name){synchronized(name){this.name = name;}}}代表的是不同的线程在synchronized块里，同时只有一个线程能执行该代码块,而类的不同实例之间是互不影响的。比如Person A = new Person(),Person B = new Person().A和B之间是不受synchronized制约的。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。

代表这个方法加索,相当于每一次运行到这个法,都要检查有没有其它正在用这个方法的程序,有的话要等其它运行完这个方法后再运行此线程,没有的话,直接运行

在多线程的情况下，由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：synchronized(syncObject) {//允许访问控制的代码}synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。 通常问这个问题应该都是涉及到多线程了，如果是在自己学java多线程编程的话，建议搭好环境多敲代码试试，会发现很多有意思的事情，无论是自己看书还是百度知道能帮到你的很少。

两者区别：1.synchronized是java内置关键字，在jvm层面，Lock是java类；2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。7.Lock是一个接口，synchronized是一个关键字，synchronized放弃锁只有两种情况：①线程执行完了同步代码块的内容②发生异常；而lock不同，它可以设定超时时间，也就是说他可以在获取锁时便设定超时时间，如果在你设定的时间内它还没有获取到锁，那么它会放弃获取锁然后响应放弃操作。你明白了吗？

　　由于同一进程内的多个线程共享内存空间 在Java中 就是共享实例 当多个线程试图同时修改某个实例的内容时 就会造成冲突 因此 线程必须实现共享互斥 使多线程同步 　　最简单的同步是将一个方法标记为synchronized 对同一个实例来说 任一时刻只能有一个synchronized方法在执行 当一个方法正在执行某个synchronized方法时 其他线程如果想要执行这个实例的任意一个synchronized方法 都必须等待当前执行 synchronized方法的线程退出此方法后 才能依次执行 　　但是 非synchronized方法不受影响 不管当前有没有执行synchronized方法 非synchronized方法都可以被多个线程同时执行 　　此外 必须注意 只有同一实例的synchronized方法同一时间只能被一个线程执行 不同实例的synchronized方法是可以并发的 例如 class A定义了synchronized方法sync（） 则不同实例a sync（）和a sync（）可以同时由两个线程来执行 　　多线程同步的实现最终依赖锁机制 我们可以想象某一共享资源是一间屋子 每个人都是一个线程 当A希望进入房间时 他必须获得门锁 一旦A获得门锁 他进去后就立刻将门锁上 于是B C D就不得不在门外等待 直到A释放锁出来后 B C D中的某一人抢到了该锁（具体抢法依赖于 JVM的实现 可以先到先得 也可以随机挑选） 然后进屋又将门锁上 这样 任一时刻最多有一人在屋内（使用共享资源） 　　Java语言规范内置了对多线程的支持 对于Java程序来说 每一个对象实例都有一把 锁 一旦某个线程获得了该锁 别的线程如果希望获得该锁 只能等待这个线程释放锁之后 获得锁的方法只有一个 就是synchronized关键字 例如 　　public class SharedResource { 　　private int count = ; 　　public int getCount（） { return count; } 　　public synchronized void setCount（int count） { unt = count; } 　　} 　　同步方法public synchronized void setCount（int count） { unt = count; } 事实上相当于 　　public void setCount（int count） { 　　synchronized（this） { // 在此获得this锁 　　unt = count; 　　} // 在此释放this锁 　　} 　　红色部分表示需要同步的代码段 该区域为 危险区域 如果两个以上的线程同时执行 会引发冲突 因此 要更改SharedResource的内部状态 必须先获得SharedResource实例的锁 　　退出synchronized块时 线程拥有的锁自动释放 于是 别的线程又可以获取该锁了 　　为了提高性能 不一定要锁定this 例如 SharedResource有两个独立变化的变量 　　public class SharedResouce { 　　private int a = ; 　　private int b = ; 　　public synchronized void setA（int a） { this a = a; } 　　public synchronized void setB（int b） { this b = b; } 　　} 　　若同步整个方法 则setA（）的时候无法setB（） setB（）时无法setA（） 为了提高性能 可以使用不同对象的锁 　　public class SharedResouce { 　　private int a = ; 　　private int b = ; 　　private Object sync_a = new Object（） 　　private Object sync_b = new Object（） 　　public void setA（int a） { 　　synchronized（sync_a） { 　　this a = a; 　　} 　　} 　　public synchronized void setB（int b） { 　　synchronized（sync_b） { 　　this b = b; 　　} lishixinzhi/Article/program/Java/gj/201311/27512

NoSuchFieldError，很明显啊，你的模型是不是没有这个字段在数据库中某个域，有可能是该域不get / set方法

说得不清楚呀。想把字符串转换成什么。

将 ch 装换成Double类型

import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class DateTest { public static void main(String[] args) throws ParseException{ String date="1988-10-10 20:10:10"; Date d=null; SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); d=sdf.parse(date);//将String to Date类型 System.out.println(d); } } 一个小例子...刚写的... 祝楼主早日成功!! 还有什么不明白的..百度HI我...!老大这是抛出一定要有的可好 。。。你没有学过异常吧？？赶紧找书学一下吧！！

public class ClassA { { System.out.println("Init Block!!"); } static { System.out.println("Static Init Block!!"); } private static ClassB sMemVariable = new ClassB( "Static Member Variable Inited!!"); public ClassA() { System.out.println("Constructer execute!!"); } public ClassB memVariable = new ClassB("Member Variable Inited!!"); public static void main(String[] args) { ClassA o = new ClassA(); ClassA o2 = new ClassA(); } } public class ClassB { public ClassB(String mes) { System.out.println(mes); } public static void main(String[] args) throws ClassNotFoundException { try { Class.forName("test.ClassA");//(1) } catch (Exception e) { } } }

楼上说得对嘛，初始化

lanhawk说的对,以前写java时获取系统环境都用Toolkit tk = this.getToolkit();

是代步的工具吧，想要达到某种结果而使用。不管是存值还是传值等

<!DOCTYPE html><html><style type="text/css">#box1{ background:#000; width:200px; margin-left:500px;}</style><script type="text/javascript">var speed=8;var status=0;//0 stands for closed, 1 stands for open;function move(){var box=document.getElementById("box1");if(status==0){ box.style.height="100px";status=1;}else {box.style.height="0px";status=0;}}</script><div id="box1"></div><input type="button" value="button" onclick="move()"/></html>上面是直接设置的height，没有动画效果，如果想做动画效果，可以考虑用jQuery中的hide和show函数，可以方便地对展开和关闭的速度进行设置。

这个脚本很糟糕，放眼望去全是Bug，不工作也是正常的，如果修改它就相当与重做。

safari 和 google都属于Webkit核心的浏览器改js引擎不支持clientHeight;clientWidth属性所以就不正常可以用offsetWidth,offsetHeight来替代

跨域问题。js在控制iframe中的东西时，是需要在相同域名下的两个页面的。也就是说，父网页和iframe中的网页要是同一个域名下的网页才行。

scrollTop是指某个可滚动区块向下滚动的距离，比如向下滚动了10个像素，那么这个元素的scrollTop属性值就是10；offsetTop则是元素的上边框与父元素的上边框的绝对距离。两者描述的不是同一个东西，所以没有可比性。

因为你没有把层的位置绝对化(position: absolute;)，left是不起作用的.下面是我写的一个例题，希望能给你参考！<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><HTML><HEAD><TITLE>AAAAAAAA</TITLE><META HTTP-EQUIV="Content-Type" CONTENT="text/html" charset="UTF-8"></HEAD><style><!--.div{position: absolute;border: 2px solid red;background-color: #EFEFEF;line-height:90px;font-size:12px;z-index:1000;}--></style><BODY><div id="Javascript.Div1" class="div" style="width: 240px; height:90px" align="center">正中...</div><SCRIPT LANGUAGE="JavaScript">function sc1(){document.getElementById("Javascript.Div1").style.top= document.documentElement.scrollTop+(document.documentElement.clientHeight-document.getElementById("Javascript.Div1").offsetHeight)/2document.getElementById("Javascript.Div1").style.left= document.documentElement.scrollLeft+(document.documentElement.clientWidth-document.getElementById("Javascript.Div1").offsetWidth)/2;}</SCRIPT><div id="Javascript.Div2" class="div" style="width: 240px; height:90px;" align="center">左上...</div><SCRIPT LANGUAGE="JavaScript">function sc2(){document.getElementById("Javascript.Div2").style.top=document.documentElement.scrollTopdocument.getElementById("Javascript.Div2").style.left=document.documentElement.scrollLeft;}</SCRIPT><div id="Javascript.Div3" class="div" style="width: 240px; height:90px;" align="center">左下...</div><SCRIPT LANGUAGE="JavaScript">function sc3(){document.getElementById("Javascript.Div3").style.top= document.documentElement.scrollTop+document.documentElement.clientHeight-document.getElementById("Javascript.Div3").offsetHeight;document.getElementById("Javascript.Div3").style.left=document.documentElement.scrollLeft;}</SCRIPT><div id="Javascript.Div4" class="div" style="width: 240px; height:90px;" align="center">右上...</div><SCRIPT LANGUAGE="JavaScript">function sc4(){document.getElementById("Javascript.Div4").style.top=document.documentElement.scrollTop;document.getElementById("Javascript.Div4").style.left= document.documentElement.scrollLeft+document.documentElement.clientWidth-document.getElementById("Javascript.Div4").offsetWidth;}</SCRIPT><div id="Javascript.Div5" class="div" style="width: 240px; height:90px;" align="center">右下...</div><SCRIPT LANGUAGE="JavaScript">function sc5(){document.getElementById("Javascript.Div5").style.top= document.documentElement.scrollTop+document.documentElement.clientHeight-document.getElementById("Javascript.Div5").offsetHeight;document.getElementById("Javascript.Div5").style.left= document.documentElement.scrollLeft+document.documentElement.clientWidth-document.getElementById("Javascript.Div5").offsetWidth;;}</SCRIPT><SCRIPT LANGUAGE="JavaScript"><!--function scall(){sc1();sc2();sc3();sc4();sc5();}window.onscroll=scall;window.onresize=scall;window.onload=scall;//--></SCRIPT><div style="position: absolute; top: 0; left: 0; width: 10000px; height: 4000px;"></div></BODY></HTML>最后希望把分给我，有什么事可以问我！40375250