Java多執行緒程式設計-（1）-執行緒安全和鎖Synchronized概念

阿新 • • 發佈：2018-12-16

一、程序與執行緒的概念

（1）在傳統的作業系統中，程式並不能獨立執行，作為資源分配和獨立執行的基本單位都是程序。

在未配置 OS 的系統中，程式的執行方式是順序執行，即必須在一個程式執行完後，才允許另一個程式執行；在多道程式環境下，則允許多個程式併發執行。程式的這兩種執行方式間有著顯著的不同。也正是程式併發執行時的這種特徵，才導致了在作業系統中引入程序的概念。

自從在 20 世紀 60 年代人們提出了程序的概念後，在 OS 中一直都是以程序作為能擁有資源和獨立執行的基本單位的。直到 20 世紀 80 年代中期，人們又提出了比程序更小的能獨立執行的基本單位——執行緒(Thread)，試圖用它來提高系統內程式併發執行的程度，從而可進一步提高系統的吞吐量。特別是在進入 20 世紀 90 年代後，多處理機系統得到迅速發展，執行緒能比程序更好地提高程式的並行執行程度，充分地發揮多處理機的優越性，因而在近幾年所推出的多處理機 OS 中也都引入了執行緒，以改善 OS 的效能。

—–以上摘自《計算機作業系統-湯小丹等編著-3 版》

（2）下圖是來自知乎使用者的解釋：

這裡寫圖片描述

通過上述的大致瞭解，基本知道執行緒和程序是幹什麼的了，那麼我們下邊給程序和執行緒總結一下概念：

（3）程序（Process）是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。在早期面向程序設計的計算機結構中，程序是程式的基本執行實體；在當代面向執行緒設計的計算機結構中，程序是執行緒的容器。程式是指令、資料及其組織形式的描述，程序是程式的實體。

（4）執行緒，有時被稱為輕量級程序(Lightweight Process，LWP），是程式執行流的最小單元。執行緒是程式中一個單一的順序控制流程。程序內一個相對獨立的、可排程的執行單元，是系統獨立排程和分派CPU的基本單位指執行中的程式的排程單位。在單個程式中同時執行多個執行緒完成不同的工作，稱為多執行緒。

（5）程序和執行緒的關係：

執行緒和程序的關係

二、Java實現多執行緒方式

（1）繼承Thread，重寫run（）方法

public class MyThread extends Thread {

    @Override
    public void run() {
        while (true) {
            System.out.println(this.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread thread = new 
 MyThread();
        thread.start(); //執行緒啟動的正確方式
    }
}

輸出結果：

Thread-0
Thread-0
Thread-0
...

另外，要明白啟動執行緒的是start（）方法而不是run（）方法，如果用run（）方法，那麼他就是一個普通的方法執行了。

（2）實現Runable介面

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("123");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable, "t1");
        thread.start();
    }
}

三、執行緒安全

執行緒安全概念：當多個執行緒訪問某一個類（物件或方法）時，這個類始終能表現出正確的行為，那麼這個類（物件或方法）就是執行緒安全的。

執行緒安全就是多執行緒訪問時，採用了加鎖機制，當一個執行緒訪問該類的某個資料時，進行保護，其他執行緒不能進行訪問直到該執行緒讀取完，其他執行緒才可使用。不會出現資料不一致或者資料汙染。執行緒不安全就是不提供資料訪問保護，有可能出現多個執行緒先後更改資料造成所得到的資料是髒資料。這裡的加鎖機制常見的如：synchronized

四、synchronized修飾符

（1）synchronized：可以在任意物件及方法上加鎖，而加鎖的這段程式碼稱為“互斥區”或“臨界區”。

（2）**不使用**synchronized例項（程式碼A）：

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count:" + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

輸出的一種結果如下：

thread3 count:2
thread4 count:1
thread1 count:2
thread2 count:3
thread5 count:0

可以看到，上述的結果是不正確的，這是因為，多個執行緒同時操作run（）方法，對count進行修改，進而造成錯誤。

（3）**使用**synchronized例項（程式碼B）：

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public synchronized void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count:" + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

輸出結果：

thread1 count:4
thread2 count:3
thread3 count:2
thread5 count:1
thread4 count:0

可以看出程式碼A和程式碼B的區別就是在run（）方法上加上了synchronized修飾。

說明如下：

當多個執行緒訪問MyThread 的run方法的時候，如果使用了synchronized修飾，那個多執行緒就會以排隊的方式進行處理（這裡排隊是按照CPU分配的先後順序而定的），一個執行緒想要執行synchronized修飾的方法裡的程式碼，首先是嘗試獲得鎖，如果拿到鎖，執行synchronized程式碼體的內容，如果拿不到鎖的話，這個執行緒就會不斷的嘗試獲得這把鎖，直到拿到為止，而且多個執行緒同時去競爭這把鎖，也就是會出現鎖競爭的問題。

五、一個物件有一把鎖！多個執行緒多個鎖！

何為，一個物件一把鎖，多個執行緒多個鎖！首先看一下下邊的例項程式碼（程式碼C）：

public class MultiThread {

    private int num = 200;

    public synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

輸出結果：

thread1 tag a,set num over!
thread1 tag a, num = 100
thread2 tag b,set num over!
thread2 tag b, num = 0

可以看出，有兩個物件：multiThread1和multiThread2，如果多個物件使用同一把鎖的話，那麼上述執行的結果就應該是：thread2 tag b, num = -100，因此，是每一個物件擁有該物件的鎖的。

關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或方法當做鎖，所以上述例項程式碼C中哪個執行緒先執行synchronized 關鍵字的方法，那個執行緒就持有該方法所屬物件的鎖，兩個物件，執行緒獲得的就是兩個不同物件的不同的鎖，他們互不影響的。

那麼，我們在正常的場景的時候，肯定是有一種情況的就是，所有的物件會對一個變數count進行操作，那麼如何實現哪？很簡單就是加static，我們知道，用static修改的方法或者變數，在該類的所有物件是具有相同的引用的，這樣的話，無論例項化多少物件，呼叫的都是一個方法，程式碼如下（程式碼D）：

public class MultiThread {

    private static int num = 200;

    public static synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start();

        Thread.sleep(5000);
        System.out.println("等待5秒，確保thread1已經執行完畢！");

        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

輸出結果：

thread1 tag a,set num over!
thread1 tag a, num = 100
等待5秒，確保thread1已經執行完畢！
thread2 tag b,set num over!
thread2 tag b, num = -100

可以看出，對變數和方法都加上了static修飾，就可以實現我們所需要的場景，同時也說明了，對於非靜態static修飾的方法或變數，是一個物件一把鎖的。

六、物件鎖的同步和非同步

（1）同步：synchronized

同步的概念就是共享，我們要知道“共享”這兩個字，如果不是共享的資源，就沒有必要進行同步，也就是沒有必要進行加鎖；

同步的目的就是為了執行緒的安全，其實對於執行緒的安全，需要滿足兩個最基本的特性：原子性和可見性;

（2）非同步：asynchronized

非同步的概念就是獨立，相互之間不受到任何制約，兩者之間沒有任何關係。

（3）示例程式碼：

public class MyObject {

    public void method() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        final MyObject myObject = new MyObject();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                myObject.method();
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                myObject.method();
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

上述程式碼中method（）就是非同步的方法。

Java多執行緒程式設計-（1）-執行緒安全和鎖Synchronized概念

一、程序與執行緒的概念

二、Java實現多執行緒方式

三、執行緒安全

四、synchronized修飾符

五、一個物件有一把鎖！多個執行緒多個鎖！

六、物件鎖的同步和非同步

Java多執行緒程式設計-（1）-執行緒安全和鎖Synchronized概念

Java多執行緒程式設計-（3）-執行緒本地ThreadLocal的介紹與使用

多執行緒程式設計（1）

Java粗淺認識-併發程式設計（四）-執行緒間通訊

Java粗淺認識-併發程式設計（五）-執行緒池

ava多執行緒程式設計-（4）-執行緒間通訊機制的介紹與使用

多執行緒程式設計（二）——執行緒結束後的處理&主服務存活方法

c++11多執行緒程式設計（四）：資料共享和競爭條件

多執行緒程式設計（2）—執行緒安全

執行緒初步（1）—— 執行緒的建立、引數和返回值、結束、狀態、取消

執行緒安全和鎖 Synchronized 概念

java多執行緒知識（1）

Java多執行緒程式設計-（5）-使用Lock物件實現同步以及執行緒間通訊

Java多執行緒程式設計-（11）-面試常客ThreadLocal出現OOM記憶體溢位的場景和原理分析

Java多執行緒程式設計-（14）-無鎖CAS操作以及Java中Atomic併發包的“18羅漢”

Java多執行緒程式設計-（12）-Java中的佇列同步器AQS和ReentrantLock鎖原理簡要分析

Java多執行緒程式設計-（9）-ThreadLocal造成OOM記憶體溢位案例演示與原理分析

Java多執行緒程式設計-（8）-多圖深入分析ThreadLocal原理

Java多執行緒程式設計-（7）-使用執行緒池實現執行緒的複用和一些坑的避免

Java多執行緒程式設計-（6）-兩種常用的執行緒計數器CountDownLatch和迴圈屏障CyclicBarrier

Java多執行緒程式設計-（1）-執行緒安全和鎖Synchronized概念

一、程序與執行緒的概念

二、Java實現多執行緒方式

三、執行緒安全

四、synchronized修飾符

五、一個物件有一把鎖！多個執行緒多個鎖！

六、物件鎖的同步和非同步

相關推薦