Java線程安全和鎖Synchronized概念

時間 2020-02-11

原文原文鏈接

1、進程與線程的概念程序員

（1）在傳統的操做系統中，程序並不能獨立運行，做爲資源分配和獨立運行的基本單位都是進程。sql

在未配置 OS 的系統中，程序的執行方式是順序執行，即必須在一個程序執行完後，才容許另外一個程序執行；在多道程序環境下，則容許多個程序併發執行。程序的這兩種執行方式間有着顯著的不一樣。也正是程序併發執行時的這種特徵，才致使了在操做系統中引入進程的概念。安全

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

-----以上摘自《計算機操做系統-湯小丹等編著-3 版》架構

（2）下圖是來自知乎用戶的解釋：Java線程安全和鎖Synchronized概念併發

經過上述的大體瞭解，基本知道線程和進程是幹什麼的了，那麼咱們下邊給進程和線程總結一下概念：異步

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

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

（5）進程和線程的關係：
Java線程安全和鎖Synchronized概念
2、Java實現多線程方式ide

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

}

3、線程安全

線程安全概念：當多個線程訪問某一個類（對象或方法）時，這個類始終能表現出正確的行爲，那麼這個類（對象或方法）就是線程安全的。

線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其餘線程不能進行訪問直到該線程讀取完，其餘線程纔可以使用。不會出現數據不一致或者數據污染。線程不安全就是不提供數據訪問保護，有可能出現多個線程前後更改數據形成所獲得的數據是髒數據。這裏的加鎖機制常見的如：synchronized
4、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代碼體的內容，若是拿不到鎖的話，這個線程就會不斷的嘗試得到這把鎖，直到拿到爲止，並且多個線程同時去競爭這把鎖，也就是會出現鎖競爭的問題。
5、一個對象有一把鎖！多個線程多個鎖！

何爲，一個對象一把鎖，多個線程多個鎖！首先看一下下邊的實例代碼（代碼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修飾的方法或變量，是一個對象一把鎖的。
6、對象鎖的同步和異步

（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程序員，我這邊準備了免費的Java架構學習資料（裏面有高可用、高併發、高性能及分佈式、Jvm性能調優、MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料）有須要的程序員朋友能夠加Java高級架構攻城獅：867923845爲何某些人會一直比你優秀，是由於他自己就很優秀還一直在持續努力變得更優秀，而你是否是還在知足於現狀心裏在竊喜！但願讀到這的您能點個小贊和關注下我，之後還會更新技術乾貨，謝謝您的支持！