記下來(lái)，很重要。
Java語(yǔ)言的關(guān)鍵字，當(dāng)它用來(lái)修飾一個(gè)方法或者一個(gè)代碼塊的時(shí)候，能夠保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該段代碼。
一、當(dāng)兩個(gè)并發(fā)線程訪問(wèn)同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。
二、然而，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問(wèn)該object中的非synchronized(this)同步代碼塊。
三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)object中所有其它synchronized(this)同步代碼塊的訪問(wèn)將被阻塞。
四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說(shuō)，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問(wèn)都被暫時(shí)阻塞。
五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用.
舉例說(shuō)明：
一、當(dāng)兩個(gè)并發(fā)線程訪問(wèn)同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。
package ths;
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();
}
}
結(jié)果：
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
二、然而，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問(wèn)該object中的非synchronized(this)同步代碼塊。
package ths;
public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, "t1" );
Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );
t1.start();
t2.start();
}
}
結(jié)果：
t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0
三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)object中所有其它synchronized(this)同步代碼塊的訪問(wèn)將被阻塞。
//修改Thread2.m4t2()方法：
public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
結(jié)果：
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0
四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說(shuō)，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問(wèn)都被暫時(shí)阻塞。
//修改Thread2.m4t2()方法如下：
public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
結(jié)果：
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0
五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用:
package ths;
public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用對(duì)象鎖
inner.m4t1();
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");
Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2");
t1.start();
t2.start();
}
}
結(jié)果：
盡管線程t1獲得了對(duì)Inner的對(duì)象鎖，但由于線程t2訪問(wèn)的是同一個(gè)Inner中的非同步部分。所以兩個(gè)線程互不干擾。
t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0
現(xiàn)在在Inner.m4t2()前面加上synchronized：
private synchronized void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
結(jié)果：
盡管線程t1與t2訪問(wèn)了同一個(gè)Inner對(duì)象中兩個(gè)毫不相關(guān)的部分,但因?yàn)閠1先獲得了對(duì)Inner的對(duì)象鎖，所以t2對(duì)Inner.m4t2()的訪問(wèn)也被阻塞，因?yàn)閙4t2()是Inner中的一個(gè)同步方法。
t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0
第二篇：
synchronized 關(guān)鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：通過(guò)在方法聲明中加入 synchronized關(guān)鍵字來(lái)聲明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對(duì)類(lèi)成員變量的訪問(wèn)：每個(gè)類(lèi)實(shí)例對(duì)應(yīng)一把鎖，每個(gè) synchronized 方法都必須獲得調(diào)用該方法的類(lèi)實(shí)例的鎖方能
執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到從該方法返回時(shí)才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進(jìn)入可執(zhí)行
狀態(tài)。這種機(jī)制確保了同一時(shí)刻對(duì)于每一個(gè)類(lèi)實(shí)例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個(gè)處于可執(zhí)行狀態(tài)（因?yàn)橹炼嘀挥?/p>
一個(gè)能夠獲得該類(lèi)實(shí)例對(duì)應(yīng)的鎖），從而有效避免了類(lèi)成員變量的訪問(wèn)沖突（只要所有可能訪問(wèn)類(lèi)成員變量的方法均被聲明為 synchronized）
。
在 Java 中，不光是類(lèi)實(shí)例，每一個(gè)類(lèi)也對(duì)應(yīng)一把鎖，這樣我們也可將類(lèi)的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對(duì)類(lèi)的靜態(tài)成
員變量的訪問(wèn)。
synchronized 方法的缺陷：若將一個(gè)大的方法聲明為synchronized 將會(huì)大大影響效率，典型地，若將線程類(lèi)的方法 run() 聲明為
synchronized ，由于在線程的整個(gè)生命期內(nèi)它一直在運(yùn)行，因此將導(dǎo)致它對(duì)本類(lèi)任何 synchronized 方法的調(diào)用都永遠(yuǎn)不會(huì)成功。當(dāng)然我們可
以通過(guò)將訪問(wèn)類(lèi)成員變量的代碼放到專(zhuān)門(mén)的方法中，將其聲明為 synchronized ，并在主方法中調(diào)用來(lái)解決這一問(wèn)題，但是 Java 為我們提供
了更好的解決辦法，那就是 synchronized 塊。
2. synchronized 塊：通過(guò) synchronized關(guān)鍵字來(lái)聲明synchronized 塊。語(yǔ)法如下：
synchronized(syncObject) {
//允許訪問(wèn)控制的代碼
}
synchronized 塊是這樣一個(gè)代碼塊，其中的代碼必須獲得對(duì)象 syncObject （如前所述，可以是類(lèi)實(shí)例或類(lèi)）的鎖方能執(zhí)行，具體機(jī)
制同前所述。由于可以針對(duì)任意代碼塊，且可任意指定上鎖的對(duì)象，故靈活性較高。
對(duì)synchronized(this)的一些理解
一、當(dāng)兩個(gè)并發(fā)線程訪問(wèn)同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線
程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。
二、然而，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問(wèn)該object中的非synchronized
(this)同步代碼塊。
三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)object中所有其它synchronized(this)
同步代碼塊的訪問(wèn)將被阻塞。
四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說(shuō)，當(dāng)一個(gè)線程訪問(wèn)object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)
object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問(wèn)都被暫時(shí)阻塞。
五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用
http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html
java中synchronized用法
打個(gè)比方：一個(gè)object就像一個(gè)大房子，大門(mén)永遠(yuǎn)打開(kāi)。房子里有 很多房間（也就是方法）。
這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門(mén)口放著一把鑰匙（key），這把鑰匙可以打開(kāi)所有上鎖的房間。
另外我把所有想調(diào)用該對(duì)象方法的線程比喻成想進(jìn)入這房子某個(gè) 房間的人。所有的東西就這么多了，下面我們看看這些東西之間如何作用的。
在此我們先來(lái)明確一下我們的前提條件。該對(duì)象至少有一個(gè)synchronized方法，否則這個(gè)key還有啥意義。當(dāng)然也就不會(huì)有我們的這個(gè)主題了。
一個(gè)人想進(jìn)入某間上了鎖的房間，他來(lái)到房子門(mén)口，看見(jiàn)鑰匙在那兒（說(shuō)明暫時(shí)還沒(méi)有其他人要使用上鎖的 房間）。于是他走上去拿到了鑰匙
，并且按照自己 的計(jì)劃使用那些房間。注意一點(diǎn)，他每次使用完一次上鎖的房間后會(huì)馬上把鑰匙還回去。即使他要連續(xù)使用兩間上鎖的房間，
中間他也要把鑰匙還回去，再取回來(lái)。
因此，普通情況下鑰匙的使用原則是：“隨用隨借，用完即還。”
這時(shí)其他人可以不受限制的使用那些不上鎖的房間，一個(gè)人用一間可以，兩個(gè)人用一間也可以，沒(méi)限制。但是如果當(dāng)某個(gè)人想要進(jìn)入上鎖的房
間，他就要跑到大門(mén)口去看看了。有鑰匙當(dāng)然拿了就走，沒(méi)有的話，就只能等了。
要是很多人在等這把鑰匙，等鑰匙還回來(lái)以后，誰(shuí)會(huì)優(yōu)先得到鑰匙？Not guaranteed。象前面例子里那個(gè)想連續(xù)使用兩個(gè)上鎖房間的家伙，他
中間還鑰匙的時(shí)候如果還有其他人在等鑰匙，那么沒(méi)有任何保證這家伙能再次拿到。 （JAVA規(guī)范在很多地方都明確說(shuō)明不保證，象
Thread.sleep()休息后多久會(huì)返回運(yùn)行，相同優(yōu)先權(quán)的線程那個(gè)首先被執(zhí)行，當(dāng)要訪問(wèn)對(duì)象的鎖被 釋放后處于等待池的多個(gè)線程哪個(gè)會(huì)優(yōu)先得
到，等等。我想最終的決定權(quán)是在JVM，之所以不保證，就是因?yàn)镴VM在做出上述決定的時(shí)候，絕不是簡(jiǎn)簡(jiǎn)單單根據(jù) 一個(gè)條件來(lái)做出判斷，而是
根據(jù)很多條。而由于判斷條件太多，如果說(shuō)出來(lái)可能會(huì)影響JAVA的推廣，也可能是因?yàn)橹R(shí)產(chǎn)權(quán)保護(hù)的原因吧。SUN給了個(gè)不保證 就混過(guò)去了
。無(wú)可厚非。但我相信這些不確定，并非完全不確定。因?yàn)橛?jì)算機(jī)這東西本身就是按指令運(yùn)行的。即使看起來(lái)很隨機(jī)的現(xiàn)象，其實(shí)都是有規(guī)律
可尋。學(xué)過(guò) 計(jì)算機(jī)的都知道，計(jì)算機(jī)里隨機(jī)數(shù)的學(xué)名是偽隨機(jī)數(shù)，是人運(yùn)用一定的方法寫(xiě)出來(lái)的，看上去隨機(jī)罷了。另外，或許是因?yàn)橐肱?/p>
的確定太費(fèi)事，也沒(méi)多大意義，所 以不確定就不確定了吧。）
再來(lái)看看同步代碼塊。和同步方法有小小的不同。
1.從尺寸上講，同步代碼塊比同步方法小。你可以把同步代碼塊看成是沒(méi)上鎖房間里的一塊用帶鎖的屏風(fēng)隔開(kāi)的空間。
2.同步代碼塊還可以人為的指定獲得某個(gè)其它對(duì)象的key。就像是指定用哪一把鑰匙才能開(kāi)這個(gè)屏風(fēng)的鎖，你可以用本房的鑰匙；你也可以指定
用另一個(gè)房子的鑰匙才能開(kāi)，這樣的話，你要跑到另一棟房子那兒把那個(gè)鑰匙拿來(lái)，并用那個(gè)房子的鑰匙來(lái)打開(kāi)這個(gè)房子的帶鎖的屏風(fēng)。
記住你獲得的那另一棟房子的鑰匙，并不影響其他人進(jìn)入那棟房子沒(méi)有鎖的房間。
為什么要使用同步代碼塊呢？我想應(yīng)該是這樣的：首先對(duì)程序來(lái)講同步的部分很影響運(yùn)行效率，而一個(gè)方法通常是先創(chuàng)建一些局部變
量，再對(duì)這些變量做一些 操作，如運(yùn)算，顯示等等；而同步所覆蓋的代碼越多，對(duì)效率的影響就越嚴(yán)重。因此我們通常盡量縮小其影響范圍。
如何做？同步代碼塊。我們只把一個(gè)方法中該同 步的地方同步，比如運(yùn)算。
另外，同步代碼塊可以指定鑰匙這一特點(diǎn)有個(gè)額外的好處，是可以在一定時(shí)期內(nèi)霸占某個(gè)對(duì)象的key。還記得前面說(shuō)過(guò)普通情況下鑰
匙的使用原則嗎。現(xiàn)在不是普通情況了。你所取得的那把鑰匙不是永遠(yuǎn)不還，而是在退出同步代碼塊時(shí)才還。
還用前面那個(gè)想連續(xù)用兩個(gè)上鎖房間的家伙打比方。怎樣才能在用完一間以后，繼續(xù)使用另一間呢。用同步代碼塊吧。先創(chuàng)建另外
一個(gè)線程，做一個(gè)同步代碼 塊，把那個(gè)代碼塊的鎖指向這個(gè)房子的鑰匙。然后啟動(dòng)那個(gè)線程。只要你能在進(jìn)入那個(gè)代碼塊時(shí)抓到這房子的鑰匙
，你就可以一直保留到退出那個(gè)代碼塊。也就是說(shuō) 你甚至可以對(duì)本房?jī)?nèi)所有上鎖的房間遍歷，甚至再sleep(10*60*1000)，而房門(mén)口卻還有
1000個(gè)線程在等這把鑰匙呢。很過(guò)癮吧。
在此對(duì)sleep()方法和鑰匙的關(guān)聯(lián)性講一下。一個(gè)線程在拿到key后，且沒(méi)有完成同步的內(nèi)容時(shí)，如果被強(qiáng)制sleep()了，那key還一
直在 它那兒。直到它再次運(yùn)行，做完所有同步內(nèi)容，才會(huì)歸還key。記住，那家伙只是干活干累了，去休息一下，他并沒(méi)干完他要干的事。為
了避免別人進(jìn)入那個(gè)房間 把里面搞的一團(tuán)糟，即使在睡覺(jué)的時(shí)候他也要把那唯一的鑰匙戴在身上。
最后，也許有人會(huì)問(wèn)，為什么要一把鑰匙通開(kāi)，而不是一個(gè)鑰匙一個(gè)門(mén)呢？我想這純粹是因?yàn)閺?fù)雜性問(wèn)題。一個(gè)鑰匙一個(gè)門(mén)當(dāng)然更
安全，但是會(huì)牽扯好多問(wèn)題。鑰匙 的產(chǎn)生，保管，獲得，歸還等等。其復(fù)雜性有可能隨同步方法的增加呈幾何級(jí)數(shù)增加，嚴(yán)重影響效率。這也
算是一個(gè)權(quán)衡的問(wèn)題吧。為了增加一點(diǎn)點(diǎn)安全性，導(dǎo)致效 率大大降低，是多么不可取啊。
synchronized的一個(gè)簡(jiǎn)單例子
public class TextThread {
public static void main(String[] args) {
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TxtThread implements Runnable {
int num = 100;
String str = new String();
public void run() {
synchronized (str) {
while (num > 0) {
try {
Thread.sleep(1);
} catch (Exception e) {
e.getMessage();
}
System.out.println(Thread.currentThread().getName()
+ "this is " + num--);
}
}
}
}
上面的例子中為了制造一個(gè)時(shí)間差,也就是出錯(cuò)的機(jī)會(huì),使用了Thread.sleep(10)
Java對(duì)多線程的支持與同步機(jī)制深受大家的喜愛(ài)，似乎看起來(lái)使用了synchronized關(guān)鍵字就可以輕松地解決多線程共享數(shù)據(jù)同步問(wèn)題。到底如
何？――還得對(duì)synchronized關(guān)鍵字的作用進(jìn)行深入了解才可定論。
總的說(shuō)來(lái)，synchronized關(guān)鍵字可以作為函數(shù)的修飾符，也可作為函數(shù)內(nèi)的語(yǔ)句，也就是平時(shí)說(shuō)的同步方法和同步語(yǔ)句塊。如果再細(xì)的分類(lèi)，
synchronized可作用于instance變量、object reference（對(duì)象引用）、static函數(shù)和class literals(類(lèi)名稱(chēng)字面常量)身上。
在進(jìn)一步闡述之前，我們需要明確幾點(diǎn)：
A．無(wú)論synchronized關(guān)鍵字加在方法上還是對(duì)象上，它取得的鎖都是對(duì)象，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會(huì)被其
他線程的對(duì)象訪問(wèn)。
B．每個(gè)對(duì)象只有一個(gè)鎖（lock）與之相關(guān)聯(lián)。
C．實(shí)現(xiàn)同步是要很大的系統(tǒng)開(kāi)銷(xiāo)作為代價(jià)的，甚至可能造成死鎖，所以盡量避免無(wú)謂的同步控制。
接著來(lái)討論synchronized用到不同地方對(duì)代碼產(chǎn)生的影響：
假設(shè)P1、P2是同一個(gè)類(lèi)的不同對(duì)象，這個(gè)類(lèi)中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調(diào)用它們。
1． 把synchronized當(dāng)作函數(shù)修飾符時(shí)，示例代碼如下：
Public synchronized void methodAAA()
{
//….
}
這也就是同步方法，那這時(shí)synchronized鎖定的是哪個(gè)對(duì)象呢？它鎖定的是調(diào)用這個(gè)同步方法對(duì)象。也就是說(shuō)，當(dāng)一個(gè)對(duì)象P1在不同的線程中
執(zhí)行這個(gè)同步方法時(shí)，它們之間會(huì)形成互斥，達(dá)到同步的效果。但是這個(gè)對(duì)象所屬的Class所產(chǎn)生的另一對(duì)象P2卻可以任意調(diào)用這個(gè)被加了
synchronized關(guān)鍵字的方法。
上邊的示例代碼等同于如下代碼：
public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)處的this指的是什么呢？它指的就是調(diào)用這個(gè)方法的對(duì)象，如P1。可見(jiàn)同步方法實(shí)質(zhì)是將synchronized作用于object reference。――那個(gè)
拿到了P1對(duì)象鎖的線程，才可以調(diào)用P1的同步方法，而對(duì)P2而言，P1這個(gè)鎖與它毫不相干，程序也可能在這種情形下擺脫同步機(jī)制的控制，造
成數(shù)據(jù)混亂：（
2．同步塊，示例代碼如下：
public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}
這時(shí)，鎖就是so這個(gè)對(duì)象，誰(shuí)拿到這個(gè)鎖誰(shuí)就可以運(yùn)行它所控制的那段代碼。當(dāng)有一個(gè)明確的對(duì)象作為鎖時(shí)，就可以這樣寫(xiě)程序，但當(dāng)沒(méi)有明
確的對(duì)象作為鎖，只是想讓一段代碼同步時(shí)，可以創(chuàng)建一個(gè)特殊的instance變量（它得是一個(gè)對(duì)象）來(lái)充當(dāng)鎖：
class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance變量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零長(zhǎng)度的byte數(shù)組對(duì)象創(chuàng)建起來(lái)將比任何對(duì)象都經(jīng)濟(jì)――查看編譯后的字節(jié)碼：生成零長(zhǎng)度的byte[]對(duì)象只需3條操作碼，而Object lock
= new Object()則需要7行操作碼。
3．將synchronized作用于static 函數(shù)，示例代碼如下：
Class Foo
{
public synchronized static void methodAAA() // 同步的static 函數(shù)
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(類(lèi)名稱(chēng)字面常量)
}
}
代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數(shù)產(chǎn)生的效果是一樣的，取得的鎖很特別，是當(dāng)前調(diào)用這
個(gè)方法的對(duì)象所屬的類(lèi)（Class，而不再是由這個(gè)Class產(chǎn)生的某個(gè)具體對(duì)象了）。
記得在《Effective Java》一書(shū)中看到過(guò)將 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來(lái)達(dá)到鎖這個(gè)Class的
目的。P1指的是由Foo類(lèi)產(chǎn)生的對(duì)象。
可以推斷：如果一個(gè)類(lèi)中定義了一個(gè)synchronized的static函數(shù)A，也定義了一個(gè)synchronized 的instance函數(shù)B，那么這個(gè)類(lèi)的同一對(duì)象Obj
在多線程中分別訪問(wèn)A和B兩個(gè)方法時(shí)，不會(huì)構(gòu)成同步，因?yàn)樗鼈兊逆i都不一樣。A方法的鎖是Obj這個(gè)對(duì)象，而B(niǎo)的鎖是Obj所屬的那個(gè)Class。
小結(jié)如下：
搞清楚synchronized鎖定的是哪個(gè)對(duì)象，就能幫助我們?cè)O(shè)計(jì)更安全的多線程程序。
還有一些技巧可以讓我們對(duì)共享資源的同步訪問(wèn)更加安全：
1． 定義private 的instance變量+它的 get方法，而不要定義public/protected的instance變量。如果將變量定義為public，對(duì)象在外界可以
繞過(guò)同步方法的控制而直接取得它，并改動(dòng)它。這也是JavaBean的標(biāo)準(zhǔn)實(shí)現(xiàn)方式之一。
2． 如果instance變量是一個(gè)對(duì)象，如數(shù)組或ArrayList什么的，那上述方法仍然不安全，因?yàn)楫?dāng)外界對(duì)象通過(guò)get方法拿到這個(gè)instance對(duì)象
的引用后，又將其指向另一個(gè)對(duì)象，那么這個(gè)private變量也就變了，豈不是很危險(xiǎn)。 這個(gè)時(shí)候就需要將get方法也加上synchronized同步，并
且，只返回這個(gè)private對(duì)象的clone()――這樣，調(diào)用端得到的就是對(duì)象副本的引用了
1、不常用的切換函數(shù)$("p").toggle();當(dāng)點(diǎn)擊切換按鈕時(shí)，隱藏元素為P行和顯示P行；
<html>
<head>
<script type="text/javascript" src="/jquery/jquery.js"></script>
<script type="text/javascript">
$(document).ready(function(){
$("button").click(function(){
$("p").toggle();
});
});
</script>
</head>
<body>
<button type="button">切換</button>
<p>This is a paragraph with little content.</p>
<p>This is another small paragraph.</p>
</body>
</html>
2、append() 函數(shù)向所匹配的 HTML 元素內(nèi)部追加內(nèi)容$(selector).append(content);
<html>
<head>
<script type="text/javascript" src="/jquery/jquery.js"></script>
<script type="text/javascript">
$(document).ready(function(){
$("button").click(function(){
$("p").append(" <b>W3School</b>.");
});
});
</script>
</head>
<body>
<h2>This is a heading</h2>
<p>This is a paragraph.</p>
<p>This is another paragraph.</p>
<button type="button">請(qǐng)點(diǎn)擊這里</button>
</body>
</html>
類(lèi)似的還有：
$(selector).html(content) 改變被選元素的（內(nèi)部）HTML
$(selector).append(content) 向被選元素的（內(nèi)部）HTML 追加內(nèi)容
$(selector).prepend(content) 向被選元素的（內(nèi)部）HTML “預(yù)置”（Prepend）內(nèi)容
$(selector).after(content) 在被選元素之后添加 HTML
$(selector).before(content) 在被選元素之前添加 HTML
3、css操作：函數(shù) css({properties}) 同時(shí)為所有匹配元素的一系列 CSS 屬性設(shè)置值：
$(selector).css({properties})
$("p").css({"background-color":"red","font-size":"200%"});
jQuery 擁有兩種用于尺寸操作的重要函數(shù)：
- $(selector).height(value)
- $(selector).width(value)
總結(jié)如：
$(selector).css(name,value) 為匹配元素設(shè)置樣式屬性的值
$(selector).css({properties}) 為匹配元素設(shè)置多個(gè)樣式屬性
$(selector).css(name) 獲得第一個(gè)匹配元素的樣式屬性值
$(selector).height(value) 設(shè)置匹配元素的高度
$(selector).width(value) 設(shè)置匹配元素的寬度
4、AJAX：
jQuery AJAX 請(qǐng)求
$(selector).load(url,data,callback) 把遠(yuǎn)程數(shù)據(jù)加載到被選的元素中
$.ajax(options) 把遠(yuǎn)程數(shù)據(jù)加載到 XMLHttpRequest 對(duì)象中
$.get(url,data,callback,type) 使用 HTTP GET 來(lái)加載遠(yuǎn)程數(shù)據(jù)
$.post(url,data,callback,type) 使用 HTTP POST 來(lái)加載遠(yuǎn)程數(shù)據(jù)
$.getJSON(url,data,callback) 使用 HTTP GET 來(lái)加載遠(yuǎn)程 JSON 數(shù)據(jù)
$.getScript(url,callback) 加載并執(zhí)行遠(yuǎn)程的 JavaScript 文件
(url) 被加載的數(shù)據(jù)的 URL（地址）
(data) 發(fā)送到服務(wù)器的數(shù)據(jù)的鍵/值對(duì)象
(callback) 當(dāng)數(shù)據(jù)被加載時(shí)，所執(zhí)行的函數(shù)
(type) 被返回的數(shù)據(jù)的類(lèi)型 (html,xml,json,jasonp,script,text)
(options) 完整 AJAX 請(qǐng)求的所有鍵/值對(duì)選項(xiàng)
略。。。
CREATE OR REPLACE PROCEDURE "LARGEDATA_INSERT" (ip_table_name in varchar2, --目標(biāo)表
ip_table_column in varchar2, --目標(biāo)字段
ip_table_select in varchar2, --SELECT 查詢語(yǔ)句
return_result out number --返回的結(jié)果1,表示成功，０表示失敗
) as
--適合大數(shù)據(jù)量的插入模板 create Templates by chenzhoumin 20110614
runTime number;--運(yùn)行總次數(shù)
i number;--當(dāng)前行數(shù)
amount number;--總行數(shù)
s_sql varchar2(10000);--SQL語(yǔ)句
e_sql varchar2(10000);--執(zhí)行SQL語(yǔ)句
countNumber number;--一次插入的數(shù)據(jù)量
begin
--set serveroutput on size 20000000000000
countNumber := 10000;
return_result := 0; --開(kāi)始初始化為0
--核必邏輯內(nèi)容，可根據(jù)具體的業(yè)務(wù)邏輯來(lái)定義,統(tǒng)計(jì)數(shù)據(jù)總行數(shù)
s_sql := 'select count(1) from (' || ip_table_select || ')';
execute immediate s_sql
into amount;
--每100萬(wàn)提交一次
runTime := amount mod countNumber;
if (runTime > 0) then
runTime := 1 + trunc(amount / countNumber);
end if;
if (runTime = 0) then
runTime := 0 + trunc(amount / countNumber);
end if;
FOR i IN 1 .. runTime LOOP
e_sql := 'insert into '||ip_table_name ||'
('||ip_table_column ||')
select '|| ip_table_column ||'
from
(select selectSec.*, rownum rownumType
from ('|| ip_table_select ||') selectSec
WHERE ROWNUM <= '|| i * countNumber ||')
WHERE rownumType > '||(i - 1) * countNumber;
dbms_output.enable(99999999999999);
dbms_output.put_line(e_sql);
execute immediate e_sql;
--提交
commit;
END LOOP;
return_result := 1;
return;
exception
when others then
return_result := 0;
raise;
dbms_output.enable(99999999999999);
dbms_output.put_line('結(jié)束');
return;
end;
以上測(cè)試通過(guò)。