并發(fā)編程基礎(chǔ)知識一

muzhuyu 發(fā)布于2019-08-16 10:44 / 1574人閱讀

摘要：如果拿不到鎖這個線程就會不斷的嘗試獲得這把鎖，直到拿到為止。關(guān)鍵字取得的鎖都是對象鎖而不是把一段代碼方法當(dāng)成鎖。多個線程對象獲得不同的鎖他們互不影響。

線程安全：當(dāng)多個線程訪問某一個類時，這個類始終都能表現(xiàn)出正確的行為，那么這個類就是線程安全的

synchronized： 可以在任意對象及方法上加鎖，而加鎖的這段代碼稱為“互斥區(qū)”或者“臨界區(qū)”

    private int count = 5;
    
    public synchronized void  run(){
        count--;
        System.err.println(this.currentThread().getName()+" count = "+count);
    }

當(dāng)多個線程訪問Thread的run()方法時，以排隊的形式進(jìn)行處理（排隊是按照CPU分配的先后順序而定的），一個線程要執(zhí)行synchronized 修飾的方法里面的代碼
1.嘗試獲得鎖
2.如果拿到鎖執(zhí)行synchronized 代碼塊內(nèi)容。如果拿不到鎖這個線程就會不斷的嘗試獲得這把鎖，直到拿到為止。而且多個線程同時去競爭這把鎖，也就是會有鎖競爭的問題

多個線程多個鎖：每個線程都可以拿到自己的指定的鎖，分別拿到鎖以后執(zhí)行synchronized方法體里面的內(nèi)容。

synchronized關(guān)鍵字取得的鎖都是對象鎖而不是把一段代碼（方法）當(dāng)成鎖。
多個線程對象獲得不同的鎖他們互不影響。

    private static int num;
    
    public static  synchronized void printNum(String tag){
        try{
            if(tag.equals("a")){
                num =100;
                System.err.println(" tag a");
                Thread.sleep(2000);
            } else{
                num = 200;
                System.err.println("tag b");
            }
        } catch(Exception e){
            e.printStackTrace();
        }
    }

在靜態(tài)方法上面加synchronized 關(guān)鍵字表示鎖定class類，獨占class類，類級別的鎖

同步：synchronized 同步的概念就是共享。如果不共享資源，沒有必須進(jìn)行同步

異步：asynchronized 異步就是獨立，相互之間不受制約。例如ajax請求

    public  synchronized void method1(){
        try {
            System.err.println(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public void method2(){
        System.err.println(Thread.currentThread().getName());
    }

1.a線程先持有Object對象的lock鎖 B線程如果在這個時候調(diào)用對象中的synchronized 方法則需要等待，也就是同步。
2.a線程先持有Object對象的lock鎖 B線程可以以異步的方式調(diào)用線程對象中的非synchronized 修飾的方法，不需要等待。

同步的目的是為了線程安全，對于線程安全需要滿足2個特性

原子性（同步）

可見性

臟讀：在設(shè)計我們的程序的時候一定要考慮到問題的整體性，不然就會出現(xiàn)很經(jīng)典的錯誤：臟讀

    public synchronized void setValue(String  username, String password){
            this.username = username;
            this.password = password;
            
            try{
                Thread.sleep(2000);
            }catch(Exception e){
                e.printStackTrace();
            }
            System.err.println("setValue的最終結(jié)果是 username "+
            username+",password"+password);
        }
    
    public void getValue(){
        System.err.println("getValue方法得到username"+
username+",password"+password);
    }

在對一個對象的方法加鎖時候，需要考慮到業(yè)務(wù)的整體性，即在setValue/getValue方法同時加上synchronized 關(guān)鍵字保證業(yè)務(wù)的原子性

鎖重入：當(dāng)一個線程獲得一個對象的鎖以后，再次請求此對象時可以再次獲得對象的鎖

    static class Main {
        public int i = 10;
        public synchronized void operationSup(){
            try {
                i--;
                System.out.println("Main print i = " + i);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    static class Sub extends Main {
        public synchronized void operationSub(){
            try {
                while(i > 0) {
                    i--;
                    System.out.println("Sub print i = " + i);
                    Thread.sleep(100);        
                    this.operationSup();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

當(dāng)涉及到父類與子類相互執(zhí)行的時候可以使用鎖重入

異常釋放鎖

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

如果一個業(yè)務(wù)分為多個子模塊去執(zhí)行。彼此之間相互獨立，如果其中一個業(yè)務(wù)出現(xiàn)異常，采取的方式是記錄日志，其他業(yè)務(wù)不受影響繼續(xù)執(zhí)行
如果一個業(yè)務(wù)分為多個子模塊去執(zhí)行，彼此之間是關(guān)聯(lián)的，如果其中一個業(yè)務(wù)出現(xiàn)異常，采取的方式是拋出RuntimeException，及時終止業(yè)務(wù)。

減小鎖的粒度：synchronized關(guān)鍵字來優(yōu)化代碼塊的執(zhí)行時間

    public void doLongTimeTask(){
        try {
            
            System.out.println("當(dāng)前線程開始：" +

 Thread.currentThread().getName() + 
                    ", 正在執(zhí)行一個較長時間的業(yè)務(wù)操作，其內(nèi)容不需要同步");
            Thread.sleep(2000);
            
            synchronized(this){
                System.out.println("當(dāng)前線程：" + 
                
                Thread.currentThread().getName() + 
                    ", 執(zhí)行同步代碼塊，對其同步變量進(jìn)行操作");
                Thread.sleep(1000);
            }
            System.out.println("當(dāng)前線程結(jié)束：" +
 Thread.currentThread().getName() +
                    ", 執(zhí)行完畢");
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

對任意的Object對象加鎖

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

對字符串常量加鎖產(chǎn)生死循環(huán)

    public void method() {
        //new String("字符串常量")
        synchronized ("字符串常量") {
            try {
                while(true){
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + "開始");
                    Thread.sleep(1000);        
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + "結(jié)束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

鎖對象改變 如果鎖所對象本身不發(fā)生改變，即使是屬性改變，那么依然是同步的。同一對象屬性的修改不會影響鎖的情況

    public synchronized void changeAttributte(String name, int age) {
        try {
            System.out.println("當(dāng)前線程 : "  + 
Thread.currentThread().getName() + " 開始");
            this.setName(name);
            this.setAge(age);
            
            System.out.println("當(dāng)前線程 : "  + 
Thread.currentThread().getName() + " 修改對象內(nèi)容為： " 
                    + this.getName() + ", " + this.getAge());
            
            Thread.sleep(2000);
            System.out.println("當(dāng)前線程 : "  + 
Thread.currentThread().getName() + " 結(jié)束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

死鎖問題：在設(shè)計程序時就應(yīng)該避免雙方相互持有對方的鎖的情況

public void run() {
        if(tag.equals("a")){
            synchronized (lock1) {
                try {
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + " 進(jìn)入lock1執(zhí)行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + " 進(jìn)入lock2執(zhí)行");
                }
            }
        }
        if(tag.equals("b")){
            synchronized (lock2) {
                try {
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + " 進(jìn)入lock2執(zhí)行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("當(dāng)前線程 : "  + 
                    Thread.currentThread().getName() + " 進(jìn)入lock1執(zhí)行");
                }
            }
        }
    }