假設i為銀行的存款資料，i = 100, 現在使用A B兩個線程(兩個人)同時執行 i = i + 10;(存10塊錢)的操作，由於預設情況下非同步執行，那麼流程可能會是這樣：
1. A線程從系統記憶體中讀到 i。
2. B線程從系統記憶體中讀到 i。
3. A線程執行 i+10。
4. B線程執行 i+10。
5. A線程將110寫回到系統記憶體,記憶體中i的值為 110。
6. B線程將110寫回到系統記憶體,記憶體中i的值為 110,。
顯然這程結果是不正確的，少了一個人存的錢。
synchronized關鍵字
我理解這個關鍵字作用是控制對象在多線程情況下，保護其在工作記憶體中只存在一份引用。
多安全執行緒執行個體：
| 代碼如下 |
複製代碼 |
|
package threads;
public class TestIPP
{
public static void main(String[] args) throws InterruptedException
{
Num num = new Num(100000);
Thread plus = new Plus(num);
Thread cut = new Cut(num);
plus.start();
cut.start();
plus.join();
cut.join();
System.out.print(num.getNum());
}
public static class Num
{
int num;
public void plus()
{
num++;
}
public void cut()
{
num--;
}
public Num(int num)
{
this.num = num;
}
public int getNum()
{
return this.num;
}
}
static public class Plus extends Thread
{
Num num;
public Plus(Num num)
{
this.num = num;
}
public void run()
{
synchronized (num) {
for (int i = 0; i < 5; i++) {
num.plus();
System.out.println("+1");
}
}
}
}
static public class Cut extends Thread
{
private Num num;
public Cut(Num num)
{
this.num = num;
}
public void run()
{
synchronized (num) {
for (int i = 0; i < 5; i++) {
num.cut();
System.out.println("-1");
}
}
}
}
} |
例了
| 代碼如下 |
複製代碼 |
|
import java.io.*;
//多線程編程
public class MultiThread
{
public static void main(String args[])
{
System.out.println("我是主線程!");
//下面建立線程執行個體thread1
ThreadUseExtends thread1=new ThreadUseExtends();
//建立thread2時以實現了Runnable介面的THhreadUseRunnable類執行個體為參數
Thread thread2=new Thread(new ThreadUseRunnable(),"SecondThread");
thread1.start();//啟動線程thread1使之處於就緒狀態
//thread1.setPriority(6);//設定thread1的優先順序為6
//優先順序將決定cpu空出時，處於就緒狀態的線程誰先佔領cpu開始運行
//優先順序範圍1到10,MIN_PRIORITY,MAX_PRIORITY,NORM_PAIORITY
//新線程繼承建立她的父線程優先順序,父線程通常有普通優先順序即5NORM_PRIORITY
System.out.println("主線程將掛起7秒!");
try
{
Thread.sleep(7000);//主線程掛起7秒
}
catch (InterruptedException e)
{
return;
}
System.out.println("又回到了主線程!");
if(thread1.isAlive())
{
thread1.stop();//如果thread1還存在則殺掉他
System.out.println("thread1休眠過長,主線程殺掉了thread1!");
}
else
System.out.println("主線程沒發現thread1,thread1已醒順序執行結束了!");
thread2.start();//啟動thread2
System.out.println("主線程又將掛起7秒!");
try
{
Thread.sleep(7000);//主線程掛起7秒
}
catch (InterruptedException e)
{
return;
}
System.out.println("又回到了主線程!");
if(thread2.isAlive())
{
thread2.stop();//如果thread2還存在則殺掉他
System.out.println("thread2休眠過長，主線程殺掉了thread2!");
}
else
System.out.println("主線程沒發現thread2,thread2已醒順序執行結束了!");
System.out.println("程式結束按任意鍵繼續!");
try
{
System.in.read();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}//main
}//MultiThread
class ThreadUseExtends extends Thread
//通過繼承Thread類,並實現它的抽象方法run()
//適當時候建立這一Thread子類的執行個體來實現多線程機制
//一個線程啟動後（也即進入就緒狀態）一旦獲得CPU將自動調用它的run()方法
{
ThreadUseExtends(){}//建構函式
public void run()
{
System.out.println("我是Thread子類的線程執行個體!");
System.out.println("我將掛起10秒!");
System.out.println("回到主線程,請稍等,剛才主線程掛起可能還沒醒過來！");
try
{
sleep(10000);//掛起5秒
}
catch (InterruptedException e)
{
return;
}
//如果該run()方法順序執行完了,線程將自動結束,而不會被主線程殺掉
//但如果休眠時間過長,則線程還存活,可能被stop()殺掉
}
}
class ThreadUseRunnable implements Runnable
//通過實現Runnable介面中的run()方法,再以這個實現了run()方法的類
//為參數建立Thread的線程執行個體
{
//Thread thread2=new Thread(this);
//以這個實現了Runnable介面中run()方法的類為參數建立Thread類的線程執行個體
ThreadUseRunnable(){}//建構函式
public void run()
{
System.out.println("我是Thread類的線程執行個體並以實現了Runnable介面的類為參數!");
System.out.println("我將掛起1秒!");
System.out.println("回到主線程,請稍等,剛才主線程掛起可能還沒醒過來！");
try
{
Thread.sleep(1000);//掛起5秒
}
catch (InterruptedException e)
{
return;
}
//如果該run()方法順序執行完了,線程將自動結束,而不會被主線程殺掉
//但如果休眠時間過長,則線程還存活,可能被stop()殺掉
}
}
//該程式可做的修改如改休眠時間或優先順序setPriority() |
