多執行緒學習筆記(二)之執行緒安全問題
執行緒安全問題的現象
首先讓我們考慮一個問題:
class Demo implements Runnable{
private int num = 100;
//實現Runnable介面,覆蓋run方法
public void run(){
show();
}
public void show(){
while (true){
if (num>0){
System.out.println(Thread.currentThread().getName()+"...sale..." +num--);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
Thread t3 = new Thread(d);
Thread t4 = new Thread(d);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
我們假設這樣一種情況,當num=1時,執行Thread-0的時候,恰巧執行完if(num>0)的判斷語句後切換到了1並且執行完System語句又回到Thread-0,那麼將會出現問題,Thread-0執行緒將會輸出-1.(由於執行緒切換是隨機的而導致的錯誤),注意由於類是覆蓋Runnable介面的run方法,介面沒有宣告過異常,因此不能在run方法後通過throws丟擲異常,而只能使用try{}catch{}塊。
執行緒安全問題的原因
原因:
1、多個執行緒在操作共享的資料。
2、操作共享資料的執行緒程式碼有多條,一個執行緒正在進行,還沒有結束的時候其他執行緒進行了一些操作。
同步程式碼塊synchronized
解決思路:就是將多條操作共享資料的執行緒程式碼封裝起來,當有執行緒在執行這些程式碼的時候,其他執行緒不可以參與運算,必須要把當前執行緒都執行完畢後,其他執行緒才可以參與運算。
class Demo implements Runnable{
private int num = 100;
private Object lock = new Object();
//實現Runnable介面,覆蓋run方法
public void run(){
while (true){
synchronized (lock){
if (num>0){
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}
在Java中使用同步程式碼塊就可以解決這個問題,同步程式碼塊的格式:
synchronize(物件){
需要被同步的程式碼塊;
}
其中的“物件”相當於一個鎖,只有執行完該程式碼塊才能釋放該物件鎖,下一個執行緒才能執行並鎖定該物件。
給指定物件加鎖
/**
* 銀行賬戶類
*/
class Account {
String name;
float amount;
public Account(String name, float amount) {
this.name = name;
this.amount = amount;
}
//存錢
public void deposit(float amt) {
amount += amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//取錢
public void withdraw(float amt) {
amount -= amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public float getBalance() {
return amount;
}
}
/**
* 賬戶操作類
*/
class AccountOperator implements Runnable{
private Account account;
public AccountOperator(Account account) {
this.account = account;
}
public void run() {
synchronized (account) {
account.deposit(500);
account.withdraw(500);
System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
}
}
}
呼叫程式碼:
Account account = new Account("zhang san", 10000.0f);
AccountOperator accountOperator = new AccountOperator(account);
final int THREAD_NUM = 5;
Thread threads[] = new Thread[THREAD_NUM];
for (int i = 0; i < THREAD_NUM; i ++) {
threads[i] = new Thread(accountOperator, "Thread" + i);
threads[i].start();
}
結果:
Thread3:10000.0
Thread2:10000.0
Thread1:10000.0
Thread4:10000.0
Thread0:10000.0
在AccountOperator 類中的run方法裡,我們用synchronized 給account物件加了鎖。這時,當一個執行緒訪問account物件時,其他試圖訪問account物件的執行緒將會阻塞,直到該執行緒訪問account物件結束。也就是說誰拿到那個鎖誰就可以執行它所控制的那段程式碼。
當有一個明確的物件作為鎖時,就可以用類似下面這樣的方式寫程式。
public void method3(SomeObject obj)
{
//obj 鎖定的物件
synchronized(obj)
{
// todo
}
}
當沒有明確的物件作為鎖,只是想讓一段程式碼同步時,可以建立一個特殊的物件來充當鎖:
class Test implements Runnable
{
private byte[] lock = new byte[0];
//private Object lock = new Object(); // 特殊的instance變數
public void method()
{
synchronized(lock) {
// todo 同步程式碼塊
}
}
public void run() {
method();
}
}
說明:零長度的byte陣列物件建立起來將比任何物件都經濟――檢視編譯後的位元組碼:生成零長度的byte[]物件只需3條操作碼,而Object lock = new Object()則需要7行操作碼。
synchronized總結
A. 無論synchronized關鍵字加在方法上還是物件上,如果它作用的物件是非靜態的,則它取得的鎖是物件;如果synchronized作用的物件是一個靜態方法或一個類,則它取得的鎖是對類,該類所有的物件同一把鎖。
B. 每個物件只有一個鎖(lock)與之相關聯,誰拿到這個鎖誰就可以執行它所控制的那段程式碼。
C. 實現同步是要很大的系統開銷作為代價的,因為同步外的執行緒都會判斷同步鎖,甚至可能造成死鎖,所以儘量避免無謂的同步控制。
同步的好處:解決了執行緒的安全問題
同步的弊端:相對降低了效率,因為同步外的執行緒都會判斷同步鎖
同步的前提:同步中必須有多個執行緒,並使用同一個鎖
class Test implements Runnable
{
public void method()
{
synchronized(lock) {
// todo 同步程式碼塊
}
}
public void run() {
private byte[] lock = new byte[0];
//private Object lock = new Object(); // 特殊的instance變數
method();
}
}
如上所示的修改導致每個執行緒開啟執行自己的run方法時,每個run方法都有自己的區域性變數lock,因此不是同一個鎖。而像正確的方式時,棧中儲存的多個引用都指向同一個鎖(原理類似於深複製,淺複製),因此可以保證安全。
同步函式
先來看一個例子:
class Bank{
private int sum;
public void add(int num){
sum+=num;
System.out.println("sum="+sum);
}
}
class Cus implements Runnable{
Bank b = new Bank();//物件b是多個執行緒的共享資料
public void run(){
for (int x=0;x<3;x++){
b.add(100);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
當一個執行緒執行sum+=num;之後,還沒有執行System語句cpu變切換到其他執行緒就造成如上現象。
修改(加上同步塊):
class Bank{
private int sum;
private Object lock = new Object();
public void add(int num){
synchronized (lock){
sum+=num;
System.out.println("name="+Thread.currentThread().getName()+"sum="+sum);
}
}
}
仔細觀察上述程式碼,同步程式碼塊synchronized是一個封裝體(帶有同步特性),而函式add本身也是種封裝,因此讓函式具有“同步性”即可:
class Bank{
private int sum;
public synchronized void add(int num){
sum+=num;
System.out.println("name="+Thread.currentThread().getName()+"sum="+sum);
}
}
我們回過來看上面出現過的一個問題的程式碼(進行了一些修改):
class Demo implements Runnable{
private int num = 100;
//實現Runnable介面,覆蓋run方法
public synchronized void run(){
while (true){
if (num>0){
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
會出現一個問題,同步的範圍加大了,因為只有if語句之後的部分是需要同步的,而範圍擴大到了run方法,導致一個執行緒進行run方法,其他執行緒無法進行,因此num–的操作完全由一個執行緒完成了。
正確的範圍加同步:
class Demo implements Runnable{
private int num = 100;
//實現Runnable介面,覆蓋run方法
public void run(){
while (true){
synchronized (this){
if (num>0){
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
}
或將同步部分提出來單獨封裝到一個方法中:
class Demo implements Runnable{
private int num = 100;
//實現Runnable介面,覆蓋run方法
public void run(){
while (true){
show();
}
}
public synchorized show(){
if (num>0){
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
因此可以總結出同步函式的格式:
寫法一:
public synchronized void method()
{
// todo
}
寫法二:
public void method()
{
synchronized(this) {
// todo
}
}
寫法一修飾的是一個方法,寫法二修飾的是一個程式碼塊,但寫法一與寫法二是等價的,都是鎖定了整個方法時的內容。
同步函式所用的鎖是this:同步函式僅僅是函式帶有了同步性,同步synchronized本身是不帶有鎖的,因此函式是帶有鎖的,函式使用的時候是被物件呼叫的,函式都有自己所屬的this,例如上述例項:
class Bank{
private int sum;
public void add(int num){
sum+=num;
System.out.println("sum="+sum);
}
}
class Cus implements Runnable{
Bank b = new Bank();//物件b是多個執行緒的共享資料
public synchronized void run(){
System.out.println("this:"+this);
for (int x=0;x<3;x++){
b.add(100);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Cus c = new Cus();
System.out.println("this:"+c);
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
對比hash值即可發現,同步函式使用的鎖是this,因此保證各個執行緒使用的是相同的鎖。
同步函式與同步程式碼塊的區別:
- 同步函式的鎖是固定的this,同步程式碼塊的鎖可以是任意的物件
- 同步程式碼塊中使用的鎖是this時可以簡化為同步函式
靜態同步函式
首先,靜態函式本身不具有this,靜態的同步函式使用的鎖是該函式所屬的位元組碼檔案物件,可以用getClass方法獲取,也可以使用“類名.class”表示(類的位元組碼檔案是唯一的,只不過可以建立多個物件而已,如果是靜態方法中,使用“類名.class”,因為getClass方法不是靜態方法)
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public synchronized static void method() {
for (int i = 0; i < 5; i ++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void run() {
method();
}
}
呼叫程式碼:
SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();
結果:
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9
syncThread1和syncThread2是SyncThread的兩個物件,但在thread1和thread2併發執行時卻保持了執行緒同步。這是因為run中呼叫了靜態方法method,而靜態方法是屬於類的,所以syncThread1和syncThread2相當於用了同一把鎖。這與Demo1是不同的。synchronized作用於一個類T時,是給這個類T加鎖,T的所有物件用的是同一把鎖。
synchorized注意事項
(1) synchronized關鍵字不能繼承。
雖然可以使用synchronized來定義方法,但synchronized並不屬於方法定義的一部分,因此,synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字,而在子類中覆蓋了這個方法,在子類中的這個方法預設情況下並不是同步的,而必須顯式地在子類的這個方法中加上synchronized關鍵字才可以。當然,還可以在子類方法中呼叫父類中相應的方法,這樣雖然子類中的方法不是同步的,但子類呼叫了父類的同步方法,因此,子類的方法也就相當於同步了。這兩種方式的例子程式碼如下:
在子類方法中加上synchronized關鍵字:
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}
在子類方法中呼叫父類的同步方法
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public void method() { super.method(); }
}
(2)在定義介面方法時不能使用synchronized關鍵字。
(3)構造方法不能使用synchronized關鍵字,但可以使用synchronized程式碼塊來進行同步。
(4)一個執行緒進入一個物件的synchronized方法(非靜態)時,其他執行緒是否可以進入此物件的其他方法?
這取決於其他方法本身,可以訪問該物件的非synchronized方法或者靜態synchronized方法,因為靜態static方法用的同步鎖是當前類的位元組碼,與非靜態方法不能同步(非靜態的方法的鎖用的是this),因此兩個方法不是用的同一個鎖,因此靜態方法可以被呼叫。
死鎖
死鎖的原因:同步的巢狀
class Demo implements Runnable{
private int num = 100;
public boolean flag = true;
private Object lock = new Object();
//實現Runnable介面,覆蓋run方法
public void run(){
if (flag){
while (true){
synchronized (lock){
show();//持有鎖lock,想進入鎖是this的show方法
}
}
}else {
while (true){
show();//持有鎖this,但是show方法中想要執行需要鎖lock
}
}
}
public synchronized void show(){
synchronized (lock){
if (num>0){
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
}
}
}
}
public class SingleDemo {
public static void main(String[] args) {
Demo t = new Demo();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{
Thread.sleep(10);
}catch (InterruptedException e){
}
t.flag = false;
t2.start();
}
}