線程與同步

時間  2019-12-10
標籤 線程 同步 简体版
原文   原文鏈接

1、線程

　　1.1多線程原理

　　咱們先定義一個線程類，代碼以下：java

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:07
 6  */
 7 public class MyThread extends Thread {
 8     /**
 9      * 利用繼承中的特色
10      * 將線程名稱傳遞,進行設置
11      *
12      * @param name 線程的名稱
13      */
14     public MyThread(String name) {
15         super(name);
16     }
17 
18     /**
19      * 重寫run方法
20      * 定義線程要執行的代碼
21      */
22     @Override
23     public void run() {
24         for (int i = 0; i < 20; i++) {
25             // getName（）方法來自父親
26             System.out.println(getName() + i);
27         }
28     }
29 }

　　再定義一個測試類，以下：編程

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:15
 6  */
 7 public class MyThreadTest {
 8     public static void main(String[] args) {
 9         MyThread mt = new MyThread("小強");
10         // 開啓新的線程
11         mt.start();
12         for (int i = 0; i < 20; i++) {
13             System.out.println("旺財" + i);
14         }
15     }
16 }

　　執行流程圖以下：安全

 

　　程序啓動時運行main時候，Java虛擬機啓動一個進程，主線程main在main()調用的時候被建立，隨着調用mt對象的start方法，另一個新的線程也啓動了，這樣，這個應用就在多線程下運行。要想讓效果看起來更明顯一些，咱們可讓打印的次數更多一些來執行。多線程

　　多線程在執行時，在棧內存中，每個執行線程都有一片本身所屬的棧內存空間，進行方法的壓棧和彈棧。ide

　　當執行線程的任務結束了，線程自動在棧內存中釋放了，可是當全部的執行線程都結束了，那麼進程就結束了。測試

 　　1.2 Thread類

　　構造方法：this

  • public Thread()：分配一個新的線程對象
  • public Thread(String name)：分配一個指定名字的新的線程對象
  • public Thread(Runable target)：分配一個帶有指定目標新的線程對象
  • public Thread(Runable target，String name)：分配一個帶有執行目標新的線程對象並指定名字

 　　經常使用方法：spa

  • public String getName()：獲取當前線程名稱
  • public void start()：致使此線程開始執行；Java虛擬機調用此線程的run方法
  • public void run()： 此線程要執行的任務在此處定義代碼
  • public static void sleep(Long milllis)：使當前正在執行的線程以指定的毫秒數暫停（暫時中止執行）
  • public static Thread currentThread()：返回對當前正在執行的線程對象的引用

 　　咱們在查詢API後能夠得知建立線程的方式總共有兩種，一種是繼承Thread類方法，一種是時間Runable接口方式，前面的咱們展現的是第一種，如今咱們講解第二種操作系統

　　1.3 建立線程的方式二

　　採用Java.lang.Runnable也是很是常見的方法之一，咱們只須要重寫run方法便可.net

　　步驟以下：

  • 定義Runnable接口的實現類，而且重寫該接口的run()方法，該run()方法的方法體一樣是該線程的執行體
  • 建立Runnable實現類的實例，並以此實例做爲Thread的target來建立Thread對象，該Thread對象纔是真正的線程對象
  • 調用線程對象的start()方法來啓動線程

　　代碼以下：

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:53
 6  */
 7 public class MyRunnable implements Runnable{
 8     @Override
 9     public void run() {
10         for (int i = 0; i < 20; i++) {
11             System.out.println(Thread.currentThread().getName()+i);
12         }
13     }
14 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 20:55
 6  */
 7 public class MyRunnableTest {
 8     public static void main(String[] args) {
 9         // 建立自定義類對象，線程任務對象
10         MyRunnable mr = new MyRunnable();
11         // 建立線程對象
12         Thread t = new Thread(mr, "小強");
13         t.start();
14         for (int i = 0; i < 20; i++) {
15             System.out.println("旺財" + i);
16         }
17     }
18 }

　　經過實現Runnable接口，使得該類有了多線程類的特性。run()方法是多線程程序的一個執行目標。全部的多線程代碼都在run方法中，Thread類實際上也是實現了Runnable接口的類。

　　在啓動多線程的時候，須要先經過Thread類的構造方法Thread(Runnable targer)構造出對象，而後調用Thread對象的start()方法來運行多線程代碼。

　　實際上全部的所線程代碼都是經過Thread的start()方法來運行的，所以，不論是繼承Thread類仍是實現Runnable接口來實現多線程，最終仍是經過Thread對象的API來控制線程的，熟悉Thread類的API是進行多線程編程的基礎。

　　tips：Runnable對象僅僅做爲Thread對象的target，Runnable實現類裏包含的run方法僅做爲線程執行體。而時間的線程對象依然是Thread實例，只是該Thread線程負責執行其target的run()方法。

　　1.4 Thread和Runable的區別

　　若是一個類繼承Thread，則不適合資源共享，可是若是實現了Runnable接口的話，則很容易的實現資源共享。

　　總結：實現Runnable接口比繼承Thread類所具備的優點：

  1. 適合鎖哥相同的程序代碼的線程去共享一個資源
  2. 能夠避免Java中出現單繼承的侷限性
  3. 增長線程的健壯性，實現解耦操做，代碼能夠被多個線程共享，代碼和線程獨立
  4. 線程池只能放入實現Runnable或者Callable類線程，不能直接放入繼承Thread的類

　　補充：在Java中，每次程序的運行至少啓動兩個線程。一個是main線程，一個是垃圾收集線程。由於每當使用Java命令執行一個類的時候，實際上都會啓動一個JVM，每個JVM其實就是在操做系統中啓動了一個進程

　　1.5 匿名內部類方式實現線程的建立

　　使用線程的匿名內部類的方式，能夠方便的實現每一個線程執行不一樣的線程操做。

　　使用匿名內部類的方式實現Runable接口，重寫Runnable接口中的run()方法：

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:15
 6  */
 7 public class NoNameInnerClassThread {
 8     public static void main(String[] args) {
 9         Runnable r = new Runnable() {
10             @Override
11             public void run() {
12                 for (int i = 0; i < 20; i++) {
13                     System.out.println("小強" + i);
14                 }
15             }
16         };
17         new Thread(r).start();
18         for (int i = 0; i < 20; i++) {
19             System.out.println("旺財" + i);
20         }
21     }
22 }

2、線程安全

　　2.1 線程安全

　　若是有多個線程在同時運行，而這些線程可能會同時運行這段代碼。程序每次運行的結構單線程同樣的，並且其餘的變量的值也和預期的是同樣的，就是線程安全的。

　　咱們用一個生活中常見的電影院賣票的案例來演示線程的安全問題：

　　咱們模擬電影院如今要播放一場電影，《楚門的世界》，本次電影總共是有100個座位，三個窗口同時開啓賣票。

　　用線程對象來模擬窗口，票的張數來模擬Runnable接口的子類

 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9     @Override
10     public void run() {
11         // 每一個窗口均可以執行賣票，窗口所有開啓
12         while (true){
13             // 有票能夠賣
14             if (ticket > 0){
15                 try {
16                     // sleep模擬出票時間
17                     Thread.sleep(100);
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21                 // 獲取當前線程對象的名字
22                 String name = Thread.currentThread().getName();
23                 System.out.println(name + "正在賣第" + ticket-- + "張票");
24             }
25         }
26     }
27 }
 1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:29
 6  */
 7 public class TicketTest {
 8     public static void main(String[] args) {
 9         // 建立線程任務對象
10         Ticket ticket = new Ticket();
11         // 建立撒個窗口對象
12         Thread thread1 = new Thread(ticket, "窗口1");
13         Thread thread2 = new Thread(ticket, "窗口2");
14         Thread thread3 = new Thread(ticket, "窗口3");
15 
16         //三個窗口同時賣票
17         thread1.start();
18         thread2.start();
19         thread3.start();
20     }
21 }

　　這時候就會出現問題：

　　後面的票提早賣，票被超賣，以及票被重複賣等等問題。

　　這種問題，就是由於幾個窗口的票數不一樣步了，咱們稱之爲線程不安全

　　線程安全問題都是由全局變量和靜態變量引發的，若是每一個線程對全局變量、靜態變量只有讀操做，而無寫操做，通常來講，這個全局變量時線程安全的，可是若是有多個線程同時執行寫操做，咱們就要考慮線程安全的問題了。

　　2.2 線程同步

　　Java中對於多線程的問題提供了同步機制（synchronized）來解決這個問題。

　　有三種方式能夠完成同步操做：

  • 同步代碼塊
    • synchronized關鍵字能夠用於方法中的某個區域中，表示對這個區塊的資源實行互斥訪問，格式以下：
    • 1 synchronized（同步鎖）{
2      須要同步操做的代碼  
3 }
    • 同步鎖：對象的同步鎖只是一個概念，能夠想象爲在對象上標記了一個鎖
      • 鎖對象能夠是任意類型
      • 多個線程對象要使用同一把鎖
      • 注意：在任什麼時候候，最多容許一個線程擁有同步鎖進入代碼塊，其餘的線程只能在外面等着
      •  1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9 
10     @Override
11     public void run() {
12         // 每一個窗口均可以執行賣票，窗口所有開啓
13         synchronized (this){
14             while (true){
15                 // 有票能夠賣
16                 if (ticket > 0){
17                     try {
18                         // sleep模擬出票時間
19                         Thread.sleep(100);
20                     } catch (InterruptedException e) {
21                         e.printStackTrace();
22                     }
23                     // 獲取當前線程對象的名字
24                     String name = Thread.currentThread().getName();
25                     System.out.println(name + "正在賣第" + ticket-- + "張票");
26                 }
27             }
28        }
29     }
30 }
  • 同步方法
    • 使用synchronized修飾的方法，就叫作同步方法，保證線程A執行該方法的時候其餘線程只能在方法外等着，格式以下：
    • 1 public synchronized void method(){
2     可能會產生線程安全問題的代碼  
3 }
    • 對於非static方法，同步鎖就是this
    • 對於static方法，咱們使用當前方法所在類的字節碼對象（類名.class）
    • 使用同步方法代碼以下：
    •  1 package com.buwei;
 2 
 3 /**
 4  * @author buwei
 5  * @date 2018/12/24 21:24
 6  */
 7 public class Ticket implements Runnable {
 8     private int ticket = 100;
 9 
10     @Override
11     public void run() {
12         // 每一個窗口均可以執行賣票，窗口所有開啓
13         while (true) {
14             sellTicket();
15         }
16     }
17 
18     public synchronized void sellTicket(){
19         // 有票能夠賣
20         if (ticket > 0){
21             try {
22                 // sleep模擬出票時間
23                 Thread.sleep(100);
24             } catch (InterruptedException e) {
25                 e.printStackTrace();
26             }
27             // 獲取當前線程對象的名字
28             String name = Thread.currentThread().getName();
29             System.out.println(name + "正在賣第" + ticket-- + "張票");
30         }
31     }
32 }

  •  Lock鎖：java.util.concurrent.locks.Lock機制提供了比synchronized代碼塊和synchronized方法更普遍的鎖定操做，同步代碼塊/同步方法具備的功能Lock都有，除此以外更強大，更體現面向對象

  • public void lock()：加同步鎖
  • public void unlock()：釋放同步鎖
  • public void trylock()：若是獲取鎖的時候鎖被佔用就返回false，不然返回true
  • 使用以下：
  •  1 package com.buwei;
 2 
 3 import java.util.concurrent.locks.Lock;
 4 import java.util.concurrent.locks.ReentrantLock;
 5 
 6 /**
 7  * @author buwei
 8  * @date 2018/12/24 21:24
 9  */
10 public class Ticket implements Runnable {
11     private int ticket = 100;
12 
13     Lock lock = new ReentrantLock();
14 
15     @Override
16     public void run() {
17         // 每一個窗口均可以執行賣票，窗口所有開啓
18         while (true) {
19             lock.lock();
20             // 有票能夠賣
21             if (ticket > 0) {
22                 try {
23                     // sleep模擬出票時間
24                     Thread.sleep(100);
25                 } catch (InterruptedException e) {
26                     e.printStackTrace();
27                 }
28                 // 獲取當前線程對象的名字
29                 String name = Thread.currentThread().getName();
30                 System.out.println(name + "正在賣第" + ticket-- + "張票");
31             }
32             lock.unlock();
33         }
34     }
35 }

 3、線程狀態

 　　3.1 線程狀態概述

 　　當線程被建立並啓動之後，它即不是一啓動就進入了執行狀態，也不是一直處於執行狀態。在線程的生命週期中，在線程的生命週期中，在Java.lang.Thread.State枚舉類中給了六種線程狀態：

　　3.2 Timed Waiting（計時等待）

　　描述：一個正在限時等待另外一個線程執行一個（喚醒）動做的線程處於這一狀態。

　　在咱們在的run方法方法中添加sleep語句就是所謂的TimedWaiting計時等待

  • 進入Timed_Waiting狀態的一種常見情形是調用的sleep方法，單獨的線程也能夠調用，不必定非要有協做關係
  • 爲了讓其餘線程有機會執行，能夠將Thread.sleep()的調用放在線程run()以內，這樣才能保證該線程執行過程當中睡眠
  • sleep與鎖無關，線程睡眠到期自動甦醒，並返回到Runnable（可運行）狀態

 　　sleep()中指定的時間是線程不會運行的最短期。所以，sleep()方法不能保證該線程睡眠到期後就開始like執行

 　　Timed Waiting線程狀態圖

　　3.3 Blocked(鎖阻塞)

 　　描述：一個正在阻塞等待一個監視器鎖（鎖對象）的線程處於這一狀態。

　　好比：線程A與線程B代碼中使用同一鎖，若是線程A獲取到鎖，線程A進入到Runnable狀態，name線程B就進入到Blocked鎖阻塞狀態。

　　這是由Runnable狀態進入Blocked狀態。除此Waiting以及Time Waiting狀態也會在某種狀況下進入阻塞狀態，Blocked線程狀態圖以下：

　　3.4 Waiting（無線等待）

 　　描述：一個正在無限期等待另外一個線程執行一個特別的（喚醒）動做的線程處於這一狀態。

　　Waiting線程狀態圖：

　　

　　3.5 補充知識點

　　tips：咱們在翻閱API的時候會發現Timed Waiting（計時等待） 與 Waiting（無限等待） 狀態聯繫仍是很緊密的，好比Waiting（無限等待） 狀態中wait方法是空參的，而timed waiting（計時等待） 中wait方法是帶參的。這種帶參的方法，實際上是一種倒計時操做，至關於咱們生活中的小鬧鐘，咱們設定好時間，到時通知，但是若是提早獲得（喚醒）通知，那麼設定好時間在通知也就顯得畫蛇添足了，那麼這種設計方案實際上是一箭雙鵰。若是沒有獲得（喚醒）通知，那麼線程就處於Timed Waiting狀態,直到倒計時完畢自動醒來；若是在倒計時期間獲得（喚醒）通知，那麼線程從Timed Waiting狀態馬上喚醒。

4、Lock鎖和synchronized的區別

　　下表來自：https://blog.csdn.net/u012403290/article/details/64910926

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程