2. 程式人生 > >多執行緒三（多執行緒資料安全問題與三種解決方式）

多執行緒三（多執行緒資料安全問題與三種解決方式）

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

      最近在做與下載相關的APK的時候，需要用到多執行緒的一些知識，之前用的不是很多很深入，所以現在重新翻出來學習並且記錄一下，這部分內容目前準備三個階段完成；第一部分是一些基本概念與多執行緒幾種常見的實現方式；第二部分是執行緒相關的一些方法以及使用過程中的一些注意事項；由於學習的調整，內容安排上優點變化，所以第三部分先簡單說一下多執行緒中資料安全問題與相應的解決方法。

1，多執行緒資料安全問題引入

多執行緒可以提高程式的使用率，也可以提高cpu的使用使用率，同時也會帶來一些弊端，比如：

  • 資料安全問題

    今天我們就先說一下多執行緒會產生什麼樣的資料安全問題；在講之前，我們需要明確：

  • cpu執行的操作是原子性的，是不可拆分的
  • 這裡說的資料安全針對的資料是多個執行緒共享的資料，所以我們會使用在第一部分中說的方式2來實現多執行緒

由此，我們可以總結出會造成多執行緒資料安全的必要條件：

  • 多執行緒環境
  • 多個執行緒操作共享資料
  • 操作共享資料的語句不是原子性的（多條）

2，程式碼演示

先舉一個搶錢的小案例，就是一共有1000元錢，現在開三個執行緒，分別是張三，李四，王五來搶這1000元錢；首先需要一個儲存資料的類：Data.java，其程式碼如下：

/**
 * @author why
 * @date 2018年3月4日
 * @description:
 */
package com.why.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Data {

public static int zsMoney = 0;
public static int lsMoney = 0;
public static int wwMoney = 0;

public static int zsHitNum = 0;
public static int lsHitNum = 0;
public static int wwHitNum = 0;

public static Object lockObject1 = new Data();
public static Object lockObject2 = new Data();

public static Lock lock=new ReentrantLock();

}

裡面有很多元素，目前不會全用到，在後面會用到；除了資料類之外，我們還需要一個實現Runnable介面的功能類，實現搶錢的功能：MoneyRunnable.java，其程式碼如下：

/**
 * @author why
 * @date 2018年2月25日
 * @description:
 */
package com.why.test;

public class MoneyRunnable implements Runnable {
private int sumMoney = 1000;
@Override
public void run() {
while(true){
if (sumMoney > 0) {

/**
* sumMoney = sumMoney - 1;
* 放在前面就不會有問題
*/
//sumMoney = sumMoney - 1;
System.out.println(Thread.currentThread().getName() + "獲得一元錢");
if (Thread.currentThread().getName().equals("張三")) {
Data.zsMoney++;
} else if (Thread.currentThread().getName().equals("李四")) {
Data.lsMoney++;
} else {
Data.wwMoney++;
}

/**
* sumMoney = sumMoney - 1;
* 放在後面就會出現資料安全問題（執行緒安全問題）
*/
sumMoney = sumMoney - 1;
} else {
System.out.println("錢搶完了:");
System.out.println("張三獲得了：" + Data.zsMoney);
System.out.println("李四獲得了：" + Data.lsMoney);
System.out.println("王五獲得了：" + Data.wwMoney);
System.out.println("他們一共獲得了："+(Data.zsMoney+Data.wwMoney+Data.lsMoney));
try {
//防止資料刷的過快，休眠一段時間
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

}

這些準備完了，就可以開始編寫測試類了：ThreadTestDemo.java，其程式碼如下：

/**
 * @author why
 * @date 2018年2月25日
 * @description:
 */
package com.why.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ThreadTestDemo {

public static void main(String[] args) {

/**
* 執行緒資料安全問題出現條件：
* 
* （1）多執行緒環境 
* （2）多個執行緒操作共享資料 
* （3）每一個執行緒共享資料的語句有多條
* 
* 解決方法： 
* （1）同步程式碼塊 
* （2）同步方法 
* （3）Lock物件鎖
*/

/**
* 搶錢案例
*/

MoneyRunnable my1 = new MoneyRunnable();
// MoneyRunnableImp my1 = new MoneyRunnableImp();
Thread t1 = new Thread(my1);
Thread t2 = new Thread(my1);
Thread t3 = new Thread(my1);
t1.setName("張三");
t2.setName("李四");
t3.setName("王五");
t1.start();
t2.start();
t3.start();

/**
* 賣票案例
*/
// TicketRunnable tr=new TicketRunnable();
// TicketRunnableImp tr=new TicketRunnableImp();
// Thread t4=new Thread(tr);
// Thread t5=new Thread(tr);
// Thread t6=new Thread(tr);
// t4.setName("視窗1");
// t5.setName("視窗2");
// t6.setName("視窗3");
// t4.start();
// t5.start();
// t6.start();

/**
* 打小明案例
*/
// HitPeopleRunnable hr = new HitPeopleRunnable();
// HitPeopleRunnableImp hr = new HitPeopleRunnableImp();
// Thread t7 = new Thread(hr);
// Thread t8 = new Thread(hr);
// Thread t9 = new Thread(hr);
// t1.setName("張三");
// t2.setName("李四");
// t3.setName("王五");
// t1.start();
// t2.start();
// t3.start();

}


}

執行測試類，有下面執行結果：

我們發現一共1000元，他們三人卻搶到了1002元，為什麼會出現這樣的問題了？而且這裡你可以多測試幾次，他們最多也只能搶到1002元，主要只因為這裡面的

sumMoney = sumMoney - 1

不是一個原子性的操作，所以很可能在執行了，sumMoney-1之後，賦值操作之前，另個執行緒進來了，所以，就會多執行一次搶錢動作，所以，你也可以開n個執行緒，最多他們可以搶到(1000+n-1)元，當然n<=1000;

3，解決方法

既然遇到上面的問題，那麼怎麼解決了；解決的方式主要有下面三種：

  • 同步程式碼塊
  • 同步方法
  • Lock物件（本身是一個介面，使用其子類）

就針對上面的案列，我們只用第一種方式來解決一下，這裡我們把MoneyRunnable.java換成MoneyRunnableImp.java：其程式碼如下：

/**
 * @author why
 * @date 2018年3月5日
 * @description:
 */
package com.why.test;


public class MoneyRunnableImp implements Runnable {


private int sumMoney = 1000;
@Override
public void run() {

while (true) { 
/**
* 同步程式碼塊實現資料安全：
* 
* 這裡面的this就是一把鎖，使用這個類建立的執行緒使用同一把鎖
* 
*/
synchronized (this) {
if (sumMoney > 0) {

/**
* sumMoney = sumMoney - 1; 放在前面就不會有問題
*/
// sumMoney = sumMoney - 1;
System.out.println(Thread.currentThread().getName() + "獲得一元錢");
if (Thread.currentThread().getName().equals("張三")) {
Data.zsMoney++;
} else if (Thread.currentThread().getName().equals("李四")) {
Data.lsMoney++;
} else {
Data.wwMoney++;
}

/**
* sumMoney = sumMoney - 1; 放在後面就會出現資料安全問題（執行緒安全問題）
*/
sumMoney = sumMoney - 1;
} else {
System.out.println("錢分完了:");
System.out.println("張三獲得了：" + Data.zsMoney);
System.out.println("李四獲得了：" + Data.lsMoney);
System.out.println("王五獲得了：" + Data.wwMoney);
System.out.println("他們一共獲得了：" + (Data.zsMoney + Data.wwMoney + Data.lsMoney));
try {
// 防止資料刷的過快，休眠一段時間
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
}

}

然後把測試ThreadTestDemo.java中的下面兩行註釋對調一下：

   MoneyRunnable my1 = new MoneyRunnable();

// MoneyRunnableImp my1 = new MoneyRunnableImp();

再次執行，結果如下：

      這個時候發現數據正常了，原理也很簡單，就是在進入同步程式碼塊之前，必須要拿到this這個鎖，當時當其他執行緒正常執行時，即便丟失cpu執行權，也不釋放this這個鎖，所以，其他執行緒無法執行，必須等待該執行緒執行完同步程式碼塊，把鎖釋放了，其他的執行緒才可以拿著這個鎖進入同步程式碼塊。

4，擴充套件部分

 前面說了有三種方式可以解決這個問題，那麼其他兩種是什麼了，為了加強練習，我又重新寫了兩個小案例，下面分別給出解決前程式碼和解決後的程式碼：

      打小明案例：

解決前程式碼：

/**

 * @author why
 * @date 2018年3月5日
 * @description:
 */
package com.why.test;


public class HitPeopleRunnable implements Runnable {


private int sumHit = 1000;

@Override
public void run() {
while (true) {

if (sumHit > 0) {

/**
* sumHit = sumHit - 1; 放在前面就不會有問題
*/
// sumMoney = sumMoney - 1;
System.out.println(Thread.currentThread().getName() + "打了小明一拳");
if (Thread.currentThread().getName().equals("張三")) {
Data.zsHitNum++;
} else if (Thread.currentThread().getName().equals("李四")) {
Data.lsHitNum++;
} else {
Data.wwHitNum++;
}

/**
* sumHit = sumHit - 1; 放在後面就會出現資料安全問題（執行緒安全問題）
*/
sumHit = sumHit - 1;
} else {
System.out.println("\n小明被打死了:");
System.out.println("張三打了小明：" + Data.zsHitNum + "拳");
System.out.println("李四打了小明：" + Data.lsHitNum + "拳");
System.out.println("王五打了小明：" + Data.wwHitNum + "拳");
System.out.println("他們一共打了小明：" + (Data.zsHitNum + Data.lsHitNum + Data.wwHitNum)+"拳");
try {
// 防止資料刷的過快，休眠一段時間
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

}

解決後代碼：

/**
 * @author why
 * @date 2018年3月5日
 * @description:
 */
package com.why.test;


public class HitPeopleRunnableImp implements Runnable {

private int sumHit = 1000;

@Override
public void run() {
while (true) {

// 這裡加鎖
Data.lock.lock();
if (sumHit > 0) {

/**
* sumHit = sumHit - 1; 放在前面就不會有問題
*/
// sumMoney = sumMoney - 1;
System.out.println(Thread.currentThread().getName() + "打了小明一拳");
if (Thread.currentThread().getName().equals("張三")) {
Data.zsHitNum++;
} else if (Thread.currentThread().getName().equals("李四")) {
Data.lsHitNum++;
} else {
Data.wwHitNum++;
}


/**
* sumHit = sumHit - 1; 放在後面就會出現資料安全問題（執行緒安全問題）
*/
sumHit = sumHit - 1;
} else {
System.out.println("\n小明被打死了:");
System.out.println("張三打了小明：" + Data.zsHitNum + "拳");
System.out.println("李四打了小明：" + Data.lsHitNum + "拳");
System.out.println("王五打了小明：" + Data.wwHitNum + "拳");
System.out.println("他們一共打了小明：" + (Data.zsHitNum + Data.lsHitNum + Data.wwHitNum) + "拳");
try {
// 防止資料刷的過快，休眠一段時間
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Data.lock.unlock();
}
}
}

      賣票案例：

解決前程式碼：

/**
 * @author why
 * @date 2018年3月5日
 * @description:
 */
package com.why.test;

public class TicketRunnable implements Runnable {
private int number = 100;
private int count =0;

@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
if (number > 0) {
System.out.println( "當前賣了"+(++count)+"張票");
System.out.println(Thread.currentThread().getName() + "出售了第：" + number + "張票");
number=number-1;
}
}
}
}

解決後代碼：

/**
 * @author why
 * @date 2018年3月5日
 * @description:
 */
package com.why.test;


public class TicketRunnableImp implements Runnable {


private int number = 100;
private int count =0;

@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
/**
* 同步方法實現資料安全：
* 
* 這裡面的this就是一把鎖，使用這個類建立的執行緒使用同一把鎖
* 
*/
sysoInfo(); 
}
}

//同步方法實現，關鍵字synchronized也可以放在許可權修飾符前面
private synchronized  void sysoInfo() {
if (number > 0) {
System.out.println( "當前賣了"+(++count)+"張票");
System.out.println(Thread.currentThread().getName() + "出售了第：" + number + "張票");
number=number-1;
}

}

}

      總結：測試程式碼還是ThreadTestDemo.java，只需要把想測試的案例註釋放開即可，測試結果這裡就不在給出。把所有的java類放在一個專案中，因為後面的案列需要使用到DATA這個資料類。後面通過Lock實現的是在jdk1.5之後才有，不過相信各位jdk肯定大於這個版本啦。同步可以改進資料安全問題，但與此同時付出的代價就是效率降低，這是一個由來已久的話題了。下一章我們會介紹互鎖與相應的解決辦法，就會使用到這部分和第二部分的知識了。

相關推薦

多執行緒三（多執行緒資料安全問題與三種解決方式）

      最近在做與下載相關的APK的時候，需要用到多執行緒的一些知識，之前用的不是很多很深入，所以現在重新翻出來學習並且記錄一下，這部分內容目前準備三個階段完成；第一部分是一些基本概念與多執行緒幾種常見的實現方式；第二部分是執行緒相關的一些方法以及使用過程中的一些注意事項

Springboot-Listener（springboot的事件監聽的4種實現方式）

prope nds ack nis stat fff span 文件中 out springboot事件監聽的4種方式 第1種： 1.自定義事件MyApplicationEvent繼承ApplicationEvent import org.springframewor

Enhancement point的開發和修改（除了出口和BADI的另外一種增強方式）

這種增強比較簡單理解和實現，而且在很多標準程式裡也會用到。 1、Enhancement point的開發：       下面這個例子是在一個普通的report裡面做增強：        插入一個增強點，有兩步：                           插入之後

python入門三（多執行緒，多程序）

python語言提供了對多執行緒、多程序的支援，下面來看看相關知識 一、python多執行緒 1、python多執行緒模組    python的多執行緒提供了兩個模組即thread和threading，threading這個模組提供了更多的功能和更高階的使用方式所以thre

C#多執行緒基礎（多執行緒的優先順序、狀態、同步）

一、關於多執行緒的優先順序、狀態、同步指令碼如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System

《瘋狂Java講義（第4版）》-----第16章【多執行緒】（控制執行緒、執行緒同步）

控制執行緒 join執行緒 等那個執行緒做完後，當前執行緒再做！ import java.lang.Thread; public class MyThread extends Thread{ public MyThread(String name){ super(

windows下多執行緒同步（利用事件物件，互斥物件，關鍵程式碼段）實現

一：利用事件實現執行緒同步 1.createthread函式的用法 hThread = CreateThread(&security_attributes, dwStackSize, ThreadProc,pParam, dwFlags, &idThre

linux多執行緒程式設計（有關執行緒操作的函式）

#include <pthread.h> int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*func) (void *), void *arg); int pth

多執行緒四（多執行緒互鎖現象與等待喚醒機制）

       最近在做與下載相關的APK的時候，需要用到多執行緒的一些知識，之前用的不是很多很深入，所以現在重新翻出來學習並且記錄一下，因為學習內容的調整，所以之前的部落格學習計劃有點變動；所以，在這裡先不給出具體的安排了，等這個模組過去之後，再重新更新一下這個系列標題與總介

java筆記--關於執行緒同步（7種同步方式）

關於執行緒同步(7種方式) 為何要使用同步？     java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查），      將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫，      從而保證了該變數的唯一性

Java併發程式設計之執行緒管理（基本執行緒同步3）

 (上一節的繼續) 2.2 使用Lock機制         Java提供了另外一種機制來同步程式碼塊。它是比synchrozied關鍵字更為強大且彈性的機制。它是基於鎖介面和實現了這個介面的類

Java併發程式設計之執行緒管理（高階執行緒同步7）

3執行緒同步實用程式 在這一節中，我們將討論如何使用高級別機制去獲得多執行緒的同步（synchronized）。這些高級別機制有下面幾種： Ø  訊號（Semaphores）：一個訊號就是一個計數

java中的多型和繼承---"編譯看左邊，執行看右邊"（多型執行）

老畢的"編譯看左邊，執行看右邊"（多型執行） （對面向物件語言中理解多型、繼承很有幫助~~~） 在多型中，成員變數的特點： 無論編譯和執行，都參考左邊（引用型變數所屬的類） 在多型中，靜態成員函式的特點：無論編譯和執行

Java併發程式設計之執行緒管理（基本執行緒同步6）

3.5 在一個鎖中使用多種狀態 一個鎖（Lock）可能和一個或者多個狀態相關聯，這些狀態在Condition介面中已經被宣告好了。這些狀態的作用就是去執行執行緒控制一個鎖或者檢查一個狀態是否為true或者false。如果是false，這個執行緒將被掛起直到其它的執行緒將它們

【轉】Mybatis傳多個參數（三種解決方案）

三種 方案 var nbsp myba rom name bsp 什麽 轉自： http://www.2cto.com/database/201409/338155.html 據我目前接觸到的傳多個參數的方案有三種。 第一種方案： DAO層的函數方法 Public

[J2EE] Servlet執行緒不安全的體現以及解決方式 筆記

        對於例項變數來說，由於servlet在Tomcat中是以單例模式存在的，所有的執行緒共享例項變數。多個執行緒對共享資源的訪問造成了執行緒不安全問題。 案例如下： import java.io.IOException; import java.io.Prin

Git詳解 三（ 多人協同開發 ，程式碼衝突）

多人協同開發 1.程式碼編輯介面介紹：此處使用gedit做演示 程式碼編輯介面左邊為模擬經理的操作 程式碼編輯介面右邊為模擬張三的操作 2.模擬張三先編輯login.py檔案程式碼 進入張三本地倉庫：cd Desktop/zhangsan/tes

Mybatis傳多個參數（三種解決方案） mapper.xml的sql語句修改！

修改 and 接收 select sql 函數 resultmap rom var 第一種 Public User selectUser(String name,String area); 對應的Mapper.xml <select id="selectUs

多線程基礎一之（線程的3種實現方式）

font dem cep urn led ring ble new t println 實現線程的三種方式： （1）繼承Thread類，重寫Run方法　 class MyThreadDemo extends Thread { @Override publi

MySQL5.7多主一從（多源複製）同步配置

MySQL5.7多主一從（多源複製）同步配置(抄襲) 原文地址：https://my.oschina.net/u/2399373/blog/2878650 多主一從，也稱為多源複製，資料流向： 主庫1 -> 從庫s 主庫2 -> 從庫s 主庫n -> 從庫s 應用場