ja

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类。

MatthewJamesWilkinsonMatthewJamesWilkinson是一名编剧，代表作品有《不可分割》、《恐怖病房》等。外文名：MatthewJamesWilkinson职业：编剧代表作品：《不可分割》、《恐怖病房》等合作人物：NickWhite电影作品

括号里的东西就是你要操作的内容呀，一个操作的逻辑，一串代码当然了，这个东西对所有试图访问它的人来说是共有的，同时只允许一个人去做举个很简单的例子，有一个打印机，同时好几个人想去用它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!

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

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

没有唤醒吧。。

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. 美国国家队成员正倒立水中，为伦敦奥运的花样游泳资格赛进行技术自选训练。

不是，可以不用synchronized，但Java推荐在调用wait方法前将对象锁住其实，从并发的角度考虑，wait是不能放在synchronized锁里的，会引起死锁。试考虑，当wait和notify方法都在synchronized锁里的时候，调用wait方法前将对象锁住，然后调用wait方法，线程被挂起，需要其它线程调用notify将其唤醒。由于notify方法也在synchronized里面，其它线程调用notify的时候要获得对象的锁，但此时锁已经被wait所在的线程持有，而且wait线程已经被挂起，所以notify因为无法获得锁而挂起，这样二者相互等待，导致死锁。Java里面可以将wait和notify放在synchronized里面，是因为Java是这样处理的：在synchronized代码被执行期间，线程调用对象的wait()方法，会释放对象锁标志，然后进入等待状态，然后由其它线程调用notify()或者notifyAll()方法通知正在等待的线程。

在分布式开发中，锁是线程控制的重要途径。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我...!老大这是抛出一定要有的可好 。。。你没有学过异常吧？？赶紧找书学一下吧！！

java中, 包装类中的valueOf其实调用的就是 Parse以下是Integer的源代码:toString是 object的一个方法, 通常用来表示对象的字符串表示形式.

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();

java提供了一组基本数据类型，包括boolean,byte,char,short,int,long,float,double,void.同时，java也提供了这些类型的封装类，分别为Boolean,Byte,Character,Short,Integer,Long,Float,Double,Void。既然提供了基本类型，为什么还要使用封装类呢？某些情况下，数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。比如，如果想使用List来保存数值，由于List中只能添加对象，因此我们需要将数据封装到封装类中再加入List。在JDK5.0以后可以自动封包，可以简写成list.add(1)的形式，但添加的数据依然是封装后的对象。另外，有些情况下，我们也会编写诸如func(Objecto)的这种方法，它可以接受所有类型的对象数据，但对于简单数据类型，我们则必须使用封装类的对象

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

<!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，不工作也是正常的，如果修改它就相当与重做。

跨域问题。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

Javascript:网页可见区域宽： document.body.clientWidth网页可见区域高： document.body.clientHeight网页可见区域宽： document.body.offsetWidth (包括边线的宽)网页可见区域高： document.body.offsetHeight (包括边线的高)网页正文全文宽： document.body.scrollWidth网页正文全文高： document.body.scrollHeight网页被卷去的高： document.body.scrollTop网页被卷去的左： document.body.scrollLeft网页正文部分上： window.screenTop网页正文部分左： window.screenLeft屏幕分辨率的高： window.screen.height屏幕分辨率的宽： window.screen.width屏幕可用工作区高度： window.screen.availHeight屏幕可用工作区宽度： window.screen.availWidthJQuery:$(document).ready(function(){alert($(window).height()); //浏览器当前窗口可视区域高度alert($(document).height()); //浏览器当前窗口文档的高度alert($(document.body).height());//浏览器当前窗口文档body的高度alert($(document.body).outerHeight(true));//浏览器当前窗口文档body的总高度 包括border padding marginalert($(window).width()); //浏览器当前窗口可视区域宽度alert($(document).width());//浏览器当前窗口文档对象宽度alert($(document.body).width());//浏览器当前窗口文档body的宽度alert($(document.body).outerWidth(true));//浏览器当前窗口文档body的总宽度 包括border padding margin})

<input type="button" value="点击" onclick="get()"><input type="text" id="_hidName"><script language="javascript"> <!-- function get(){ var t=document.getElementById("_hidName").offsetTop;var l=document.getElementById("_hidName").offsetLeft;alert("top="+t+"\nleft="+l);}</script>

相对于屏幕的坐标没办法取页面的坐标可以获取offsetTop然后一直加offsetParent的offsetTop你最好使用jquery这种类库来处理，他已经屏蔽了浏览器兼容性问题 补充：元素的页面坐标就是直接访问属性，难道这个代码也要写出来么？你还使用jquery吧，容易使用的多，而且可以直接设置相对于父对象的坐标位置

元素的宽度，高度，离左边的距离，离右边的距离。比如：我想知道body的宽度，高度，离左边的距离，离右边的距离.通过document.body.offsetWidth,document.body.offsetHeight,document.body.offsetLeft,document.body.offsetRight便可以计算出来、

class 是java的关键字, 在声明java类时使用;Class 是java JDK提供的一个类,完整路径为 java.lang.Class;区别是指两个或两个以上的事物间的不同,当两种相似的事物作比较时，它们的不同点便是区别。那么 class和Class的相似性就只有一个,那都是单词"class",就是一个为首字母大写,一个为小写.class和Class的作用:1. class只用于类声明;2. Class则用于抽象类的相关信息. java是面向对象的, 一般是把一些事物抽象成一个类,比如将学生信息抽象成Student这个类;Student类会抽象学生的姓名/性别/生日等信息;那么java中也就把java中的类也抽象成了一个类叫Class;Class中抽象了类的包名/类名/属性数组/方法数组等;

public class TestDemo{ public static void main(String[] args){ int[][] score = {{100,93,92},{88,99,76},{95,80,99},{100,88,79},{99,87,89}}; int[] avg = new int[5]; for(int i = 0; i < score.length; i++){ System.out.print("第" +(i + 1) + "个学生的三门课成绩为:"); for(int j = 0; j < score[i].length; j++){ System.out.print(score[i][j] + " "); avg[i] += score[i][j]; } System.out.println(); avg[i] = avg[i] / 3; } for(int i = 0; i < avg.length; i++){ System.out.println("第" + (i + 1) + "个学生的平均成绩是" + avg[i]); } int[] avgscore = new int[3]; for(int i = 0; i < 3; i++){ for(int j = 0; j < 5; j++){ avgscore[i] += score[j][i]; } avgscore[i] = avgscore[i] / 5; } for(int i = 0; i < avgscore.length; i++){ System.out.println("第" + (i + 1) + "门学科的平均成绩是" + avgscore[i]); } int[] maxscore = {score[0][0], score[0][1], score[0][2]}; for(int i = 0; i < 3; i++){ for(int j = 0; j < 5; j++){ if(score[j][i] > maxscore[i]){ maxscore[i] = score[i][j]; } } } for(int i = 0; i < maxscore.length; i++){ System.out.println("第" + (i + 1) + "门学科的最高分" + maxscore[i]); } }}请采纳 不过算法是很简陋

你好，很高兴回答你的问题。i++这样的有没有使用过呢，了解吗？就是相当于i=i+1。这里的Score[i][j]++是一样道理。相当于Score[i][j]=Score[i][j]+1。如果有帮助到你，请点击采纳。

java作为互联网编程中使用范围最广泛的编程语言之一，我们有许多的知识是需要掌握学习的，今天java课程培训机构就给大家分析讲解一下java面向对象的编程方法有哪些。常用的创建对象的模式有以下几种：一.工厂模式工厂模式抽象了具体对象的过程，用函数来封装以特ing接口创建对象的细节。如下：functioncreateAnimal(name,age){varo=newObject();o.name=name;o.age=age;o.sayName=function(){alert(this.name);}returno;}varcat=createAnimal("cat",12);vardog=createAnimal("dog",3);工厂模式虽然解决了创建多个相似兑现过的问题，但是却没有解决对象识别的问题。二.构造函数模式构造函数模式可以创建特定类型的对象。functionAnimal(name,age){this.name=name;this.age=age;this.sayName=function(){alert(this.name);}}varcat=newAnimal("cat",12);vardog=newAnimal("dog",3);可以使用对象的constructor属性或instanceof操作符来标识对象类型。cat.constructor==Animal//truecatinstanceofAnimal//true三.原型模式每个函数都有一个prototype(原型)属性。这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。使用原型对象的好处是，可以让所有对象实例共享它所包含的属性和方法。functionAnimal(){}Animal.prototype.name="animal";Animal.prototype.age=1;Animal.prototype.sayName=function(){alert(this.name);}vartest1=newAnimal();test1.sayName();//"animal"vartest2=newAnimal();test2.sayName();//"animal"alert(test1.sayName===test2.sayName);//true或者：functionAnimal(){}Animal.prototype={constructor:Animal,name:"animal",age:1,sayName:function(){alert(this.name);}};原型中所有属性是被很多实例共享的，通过在实例上添加一个同名属性，可以隐藏原型中的对应属性。但是，对于包含引用类型值的属性来说，问题就比较明显了。

Circle circle=new Circle（）;Triang triang= new Triang（）;Ladder ladder=new Ladder（）;

class Mystery//定义一个Mystery类，包含一个字符串变量s{String s="original";//初值public static void main(String[] args){Mystery m=new Mystery();//new产生一个Mystery类的实例m，调用构造方法Mystery()m.go();//调用go();输出//new的使用格式：[已经存在的类名] [要产生的对象名称]=new [已经存在的类名](参数);}Mystery()//用来给字符串变量赋值s 构造方法//前面的void去了，有void在就不是构造方法，将void去掉，才是构造方法才执行赋值过程{s="constructor";//将字符串“constructor” 赋给字符串变量s}void go()//输出函数（方法）{System.out.println(s);} }

没有错

你new的时候调用了metrry的构造方法给s赋值了，然后再调用go的方法输出，就是这样的

使用new关键字：这是我们最常见的也是最简单的创建对象的方式，通过这种方式我们还可以调用任意的够赞函数（无参的和有参的）。比如：Student student = new Student();使用Class类的newInstance方法：我们也可以使用Class类的newInstance方法创建对象，这个newInstance方法调用无参的构造器创建对象，如：Student student2 = (Student)Class.forName("根路径.Student").newInstance();　或者：Student stu = Student.class.newInstance();使用Constructor类的newInstance方法：本方法和Class类的newInstance方法很像，java.lang.relect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。如： Constructor<Student> constructor = Student.class.getInstance(); Student stu = constructor.newInstance();　这两种newInstance的方法就是大家所说的反射，事实上Class的newInstance方法内部调用Constructor的newInstance方法。这也是众多框架Spring、Hibernate、Struts等使用后者的原因。使用Clone的方法：无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面的对象的内容全部拷贝进去，用clone方法创建对象并不会调用任何构造函数。要使用clone方法，我们必须先实现Cloneable接口并实现其定义的clone方法。如：Student stu2 = <Student>stu.clone();这也是原型模式的应用。使用反序列化：当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象，在反序列化时，JVM创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现Serializable接口。如：ObjectInputStream in = new ObjectInputStream (new FileInputStream("data.obj")); Student stu3 = (Student)in.readObject();

好处？在单例的时候，可以保证只有一个实例，好处不多，私有会导致spring不能帮你实例话bean那么，如果被注解，或者被作为一个bean的话会报错，所以如果不是特殊情况没有必要私有，而且如果你有带参数的构造方法，也需要时刻记得生成一个无参数的构造，

答案是private修饰的构造函数是不可以new的 ；public修饰的构造函数是可以new 的举例如下：1、定义一个类Constructor 无参和有参构造分别public 、private修饰package BaiduKnows;public class Constructor {private int x=1;public Constructor() {System.out.println(" 无参是有构造函数");}private Constructor(int x) {this.x=x;System.out.println("带参共有构造函数 X="+x);}}2、从新定义测试类：package BaiduKnows;public class ConstructorTest {public static void main(String[] args) {Constructor con = new Constructor();//这是可以的//Constructor con = new Constructor(20);这不可以}}