Java線程安全和鎖Synchronized概念

1、進程與線程的概念

(1)在傳統的操做系統中,程序並不能獨立運行,做爲資源分配和獨立運行的基本單位都是進程。安全

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

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

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

(2)下圖是來自知乎用戶的解釋:異步

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

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

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

(5)進程和線程的關係:ui

2、Java實現多線程方式

(1)繼承Thread,重寫run()方法this

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()就是異步的方法。

相關文章
相關標籤/搜索