【多執行緒高併發】執行緒安全
關鍵字：執行緒安全，synchronized，多個執行緒多個鎖，物件鎖的同步和非同步，髒讀，synchronized鎖重入，synchronized程式碼塊，volatile關鍵字
執行緒安全
當多個執行緒訪問某一個類（物件或者方法）時，這個累始終都能表現出正確的行為，那麼這個類（物件或方法）就是執行緒安全的
1.1 synchronized
synchronized可以在任意的物件以及方法上加鎖，加鎖的這段程式碼稱為"互斥區"。當多個執行緒訪問某一個方法時，會以排隊的方式進行處理（這裡按照cpu分配的先後順序而定），一個執行緒想要執行synchronized修飾的方法裡面的程式碼。首先要嘗試獲得鎖，如果拿到鎖，執行synchronized程式碼體內容，拿不到鎖，這個執行緒就會不斷的嘗試得到這把鎖，知道拿到為止。而且是多個執行緒同時競爭這把鎖
例子 sync001 ：
run方法不加鎖
public class MyThread extends Thread{
private int count = 5 ;
//synchronized加鎖
public void run(){
count--;
System.out.println(this.currentThread().getName() + " count = "+ count);
}
public static void main(String[] args) {
/**
* 分析：當多個執行緒訪問myThread的run方法時，以排隊的方式進行處理（這裡排對是按照CPU分配的先後順序而定的），
* 一個執行緒想要執行synchronized修飾的方法裡的程式碼：
* 1 嘗試獲得鎖
* 2 如果拿到鎖，執行synchronized程式碼體內容；拿不到鎖，這個執行緒就會不斷的嘗試獲得這把鎖，直到拿到為止，
* 而且是多個執行緒同時去競爭這把鎖。（也就是會有鎖競爭的問題）
*/ 如果給run方法加一把鎖，其他程式碼不變，上面的run方法修改如下
//synchronized加鎖
public synchronized void run(){
count--;
System.out.println(this.currentThread().getName() + " count = "+ count);
}
--------無論執行多少次，結果都為----
t3 count = 4
t2 count = 3
t1 count = 2
t5 count = 1
t4 count = 0
1.2 多個執行緒多個鎖
關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼（方法）當做鎖，所以程式碼中哪個執行緒先執行synchronized關鍵字的方法，哪個執行緒就持有該方法所屬物件的鎖（Lock），兩個物件，執行緒獲得的就是兩個不同的鎖，他們互不影響
有一種情況則是相同的鎖，即在靜態方法上加synchronized 關鍵字，表示鎖定.class類。類一級別的鎖
例子 sync002：
public class MultiThread {
private int num = 0;
/** static */
public synchronized void printNum(String tag){
try {
if(tag.equals("a")){
num = 100;
System.out.println("tag a, set num over!");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("tag b, set num over!");
}
System.out.println("tag " + tag + ", num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//注意觀察run方法輸出順序
public static void main(String[] args) {
//倆個不同的物件
final MultiThread m1 = new MultiThread();
final MultiThread m2 = new MultiThread();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
t1.start();
t2.start();
}
}
按照我們的希望，由於printNum方法加鎖了, 我們希望t1執行緒執行完後，再執行t2執行緒, 實際上我們看到的結果如下, t1並沒有執行完，就執行了t2執行緒
tag a, set num over!
tag b, set num over!
tag b, num = 200
tag a, num = 100
原因是雖然在printNum方法中加鎖了，但是由於這裡是兩個物件， m1和m2，這裡就對應著兩把鎖，兩把鎖各自肯定互不影響.
類鎖: 在上面的這個例子當中，如果給synchronized方法加上static進行修飾，那麼就相當於給這個類加鎖。這兩把鎖就會變成同一把鎖了.
上面的例子修改程式碼如下，其他不變
private static int num = 0;
/** static */
public static synchronized void printNum(String tag){
try {
if(tag.equals("a")){
num = 100;
System.out.println("tag a, set num over!");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("tag b, set num over!");
}
System.out.println("tag " + tag + ", num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
輸出為
tag a, set num over!
tag a, num = 100
tag b, set num over!
tag b, num = 200
1.3 物件鎖的同步和非同步
同步: synchronized
同步的概念就是共享，如果不是共享的資源，就沒有必要進行同步
非同步: asynchronized
非同步的概念就是獨立，相互之間不受任何制約，類似於頁面Ajax請求，我們還可以繼續瀏覽或操作頁面的內容，而這之間沒有任何關係
同步的目的就是為了執行緒安全，對於執行緒安全來說，需要滿足兩個特性
- 原子性
- 可見性
例子sync003
t1執行緒呼叫mo.method1()方法，該方法加有鎖，這個方法需要等待，也就是同步
t2執行緒呼叫mo.method2()方法，該方法沒有加鎖，這個方法是非同步的
public class MyObject {
public synchronized void method1(){
try {
System.out.println(Thread.currentThread().getName());
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/** synchronized */
public void method2(){
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
final MyObject mo = new MyObject();
/**
* 分析：
* t1執行緒先持有object物件的Lock鎖，t2執行緒可以以非同步的方式呼叫物件中的非synchronized修飾的方法
* t1執行緒先持有object物件的Lock鎖，t2執行緒如果在這個時候呼叫物件中的同步（synchronized）方法則需等待，也就是同步
*/
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
mo.method1();
}
},"t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
mo.method2();
}
},"t2");
t1.start();
t2.start();
}
}
1.4 髒讀
對於物件的同步和非同步方法，我們在設計自己的程式的時候，一定要考慮問題的整體性，不然就會出現資料不一致的錯誤，很經典的錯誤就是髒讀(dirtyread )
例子： sync004
我們在對一個物件的方法加鎖的時候，需要考慮業務的整體性，即為setValue/getValue 方法同時加鎖synchronized同步關鍵字, 保證業務的原子性，不然會出現業務錯誤
下面的例子中，我希望先set完之後，再get內容，但是我在set的時候讓t1執行緒休眠2秒鐘，而主方法只休息一秒，這樣，會導致名字設定完了，但是密碼還沒有設定，但是主執行緒呼叫了getValue()方法，產生了密碼的髒讀
public class DirtyRead {
private String username = "kaishun";
private String password = "123";
public synchronized void setValue(String username, String password){
this.username = username;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.password = password;
System.out.println("setValue最終結果：username = " + username + " , password = " + password);
}
public void getValue(){
System.out.println("getValue方法得到：username = " + this.username + " , password = " + this.password);
}
public static void main(String[] args) throws Exception{
final DirtyRead dr = new DirtyRead();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
dr.setValue("z3", "456");
}
});
t1.start();
Thread.sleep(1000);
dr.getValue();
}
}
輸出
getValue方法得到：username = z3 , password = 123
setValue最終結果：username = z3 , password = 456
若想要達到先set完才能get，只需要在get的時候也加上同步synchronized
1.5 synchronized的其他概念
synchronized鎖重入:
關鍵字synchronized擁有鎖重入的功能，也就是在使用synchronized事，當一個執行緒得到了一個物件的鎖喉，再次請求此物件時是可以再次得到該物件的鎖。
示例 SyncException
這個案例是通過一個丟擲一個異常，來釋放鎖，但是，需要注意的是：很多異常釋放鎖的情況，如果不及時處理，很可能導致程式業務出錯。比如你在執行一個佇列任務，很多物件都去在等待對一個物件正確執行完畢後再去釋放鎖，但是第一個物件由於異常的出現，導致業務邏輯沒有正常執行完畢，就釋放了鎖，那麼可想而知後續的物件執行的都是錯位的邏輯。所以這一點需要引起注意，在編寫程式碼的時候，一定要考慮周全.
public class SyncException {
private int i = 0;
public synchronized void operation(){
while(true){
try {
i++;
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " , i = " + i);
if(i == 20){
//Integer.parseInt("a");
throw new RuntimeException();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
final SyncException se = new SyncException();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
se.operation();
}
},"t1");
t1.start();
}
}
Java內建鎖synchronized的可重入性
當執行緒請求一個由其它執行緒持有的物件鎖時，該執行緒會阻塞，而當執行緒請求由自己持有的物件鎖時，如果該鎖是重入鎖,請求就會成功,否則阻塞.
例子 com.kaishun.base.sync005 SyncDubbo1 類 :
由於synchronized是重入鎖，當呼叫method1時，在method1的內部，由於是一個執行緒，會在method1內再次請求一次sd這個物件鎖，所以能在method1()方法中執行method2()方法，而不會造成死鎖
public class SyncDubbo1 {
public synchronized void method1(){
System.out.println("method1..");
method2();
}
public synchronized void method2(){
System.out.println("method2..");
method3();
}
public synchronized void method3(){
System.out.println("method3..");
}
public static void main(String[] args) {
final SyncDubbo1 sd = new SyncDubbo1();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
sd.method1();
}
});
t1.start();
}
}
輸出
method1..
method2..
method3..
再舉一個例子 com.kaishun.base.sync005.SyncDubbo2 ：
子類也可以重入父類
public class SyncDubbo2 {
static class A {
public int i = 10;
public synchronized void methodA(){
try {
i--;
System.out.println("A print i = " + i);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class B extends A {
public synchronized void methodB(){
try {
while(i > 0) {
i--;
System.out.println("B print i = " + i);
Thread.sleep(100);
this.methodA();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
B sub = new B();
sub.methodB();
}
});
t1.start();
}
}
------------------輸出-----------------
B print i = 9
A print i = 8
B print i = 7
A print i = 6
B print i = 5
A print i = 4
B print i = 3
A print i = 2
B print i = 1
A print i = 0
1.6 synchronized程式碼塊
synchronized可以使用任意的Object進行加鎖，用法比較靈活
舉例 com.kaishun.base.sync006.ObjectLock：
/**
* 使用synchronized程式碼塊加鎖,比較靈活
* @author alienware
*
*/
public class ObjectLock {
public void method1(){
synchronized (this) { //物件鎖
try {
System.out.println("do method1..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void method2(){ //類鎖
synchronized (ObjectLock.class) {
try {
System.out.println("do method2..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private Object lock = new Object();
public void method3(){ //任何物件鎖
synchronized (lock) {
try {
System.out.println("do method3..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
final ObjectLock objLock = new ObjectLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method1();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method2();
}
})