本文實例講述了JAVA多線程編程。分享給大家供大家參考,具體如下:
網(wǎng)站建設(shè)哪家好,找成都創(chuàng)新互聯(lián)公司!專注于網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、微信小程序開發(fā)、集團(tuán)企業(yè)網(wǎng)站建設(shè)等服務(wù)項目。為回饋新老客戶創(chuàng)新互聯(lián)還提供了泊頭免費建站歡迎大家使用!
并發(fā)性和并行性的區(qū)別:
并行性:在同一時刻,有多條指令在多個處理器上同時執(zhí)行(多個CPU)
并發(fā)性:在同一時刻只能有一條指令執(zhí)行,但多個進(jìn)程指令被快速輪換執(zhí)行,使得宏觀上具有多個進(jìn)程同時執(zhí)行的效果(單核)。
public class Deom_1 extends Thread{ public void run(){ super.run(); System.out.println("MyThread01"); } public static void main(String[] args){ Deom_1 demo=new Deom_1(); demo.setName("Demo_1"); demo.start(); System.out.println("當(dāng)前線程的名字:"+Thread.currentThread().getName()+" 運行結(jié)束"); } }
多次調(diào)用start會拋出
java.lang.IllegalThreadStateException
異常
如果只調(diào)用run(),不調(diào)用start()方法,就相當(dāng)于調(diào)用了一個普通的函數(shù),實際上還是在同一個線程中運行的run()方法。
//通過實現(xiàn)Runnable接口來創(chuàng)建線程類 public class SecondThread implements Runnable { private int i ; //run方法同樣是線程執(zhí)行體 public void run() { for ( ; i < 20 ; i++ ) { //當(dāng)線程類實現(xiàn)Runnable接口時, //如果想獲取當(dāng)前線程,只能用Thread.currentThread()方法。 System.out.println(Thread.currentThread().getName() + " " + i); } } public static void main(String[] args) { for (int i = 0; i < 50; i++) { System.out.println(Thread.currentThread().getName() + " " + i); if (i == 20) { SecondThread st = new SecondThread(); //通過new Thread(target , name)方法創(chuàng)建新線程 new Thread(st , "新線程1").start(); new Thread(st , "新線程2").start(); } } } }
采用實現(xiàn)繼承方式的多線程:
編程相對簡單
多條線程之間無法共享線程類實例變量
繼承Thread類之后就不能繼承其他的父類
采用實現(xiàn)接口的方式的多線程:
線程類只是實現(xiàn)了Runnable接口,還可以繼承其他類
在這種方式下,可以多個線程共享同一個對象,非常適合多個相同線程來處理同一份資源的情況。
編程稍稍復(fù)雜一點
線程的生命周期:新建(NEW)、就緒(Runnable)、運行(Running)、阻塞(Blocked)、死亡(Dead)
當(dāng)程序使用new關(guān)鍵字創(chuàng)建一個線程后,該線程就處于新建狀態(tài);當(dāng)線程對象調(diào)用了start()方法之后,該線程就處于就緒狀態(tài);如果處于就緒狀態(tài)的線程獲得了CPU,開始執(zhí)行run方法的線程執(zhí)行體,則該線程就處于運行狀態(tài);但是它不可能一直處于運行狀態(tài),可能會被中斷進(jìn)入阻塞狀態(tài);線程運行結(jié)束后就會進(jìn)入到死亡狀態(tài)。
線程進(jìn)入阻塞狀態(tài)的情況:
線程調(diào)用了sleep方法主動放棄所占有的資源
線程調(diào)用了一個阻塞式IO方法,在該方法返回的時候被阻塞
線程嘗試獲取一個同步監(jiān)聽器,但是被其他線程占有
在等待某個通知
調(diào)用線程suspend方法掛起,不推薦使用容易造成死鎖。
線程進(jìn)入就緒狀態(tài)的情況:
調(diào)用sleep方法的線程經(jīng)過了指定時間
線程調(diào)用的阻塞式IO方法已經(jīng)返回
線程成功獲取試圖取得同步監(jiān)聽器
線程在等待某個通知,其他線程發(fā)出一個通知
處于掛起狀態(tài)的線程調(diào)用了resume恢復(fù)方法
進(jìn)入阻塞狀態(tài)的線程在獲得執(zhí)行機會后重新進(jìn)入就緒狀態(tài),而不是運行狀態(tài)。
當(dāng)主線程結(jié)束的時候,其他線程不受影響。一旦子線程啟動它就擁有和主線程一樣的地位。
不要試圖對一個已經(jīng)死亡的線程調(diào)用start()方法使它重新啟動,會拋出IllegalThreadStateException
異常。調(diào)用線程的isAlive()
方法可以測試某條線程是否死亡。
JAVA中控制線程的方法:
join線程
后臺線程
線程睡眠:sleep
線程讓步:yield
改變線程優(yōu)先級
join線程
join()
:等待被join的線程執(zhí)行完成
join(long millis)
:等待被join的線程時間最長millis毫秒
join(long millis, int nanos)
:等待被join的線程的時間最長millis毫秒加上nanos微秒
后臺線程:任務(wù)是給其他線程提供服務(wù),成為“后臺線程”、“守候線程”。如果說有的前臺線程死亡,后臺線程會自動死亡。
調(diào)用Thread類的
setDaemon(true)
方法可以將指定線程設(shè)置為后臺線程。該方法一定要在啟動線程之前設(shè)置,否則會發(fā)生異常。同時提供isDaemon()
方法判斷是否是后臺線程。主線程一般默認(rèn)為前臺線程。前臺線程創(chuàng)建的子線程默認(rèn)是前臺,后臺線程創(chuàng)建的子線程默認(rèn)是后臺。
PriorityTest low = new PriorityTest("低級"); low.start(); System.out.println("創(chuàng)建之初的優(yōu)先級:" + low.getPriority()); //設(shè)置該線程為最低優(yōu)先級 low.setPriority(Thread.MIN_PRIORITY);
PriorityTest high = new PriorityTest("高級"); high.start(); System.out.println("創(chuàng)建之初的優(yōu)先級:" + high.getPriority()); //設(shè)置該線程為最高優(yōu)先級 high.setPriority(Thread.MAX_PRIORITY);
每個線程的默認(rèn)優(yōu)先級都與創(chuàng)建它的父線程具有相同的線程,在默認(rèn)的情況下,main線程具有普通優(yōu)先級。
線程讓步
yield()方法是Thread提供的一個靜態(tài)方法,可以讓當(dāng)前正在執(zhí)行的線程暫停轉(zhuǎn)入就緒狀態(tài)。等待下一次的重新調(diào)度。
實際上,當(dāng)某個線程調(diào)用了yield()方法后只有優(yōu)先級相同或者高于當(dāng)前線程的其他就緒狀態(tài)的線程才會獲得執(zhí)行的機會。
sleep和yield方法的區(qū)別
1、sleep方法暫停當(dāng)前線程后,會給其他線程機會執(zhí)行,不會理會其他線程的優(yōu)先級。但是yield方法只會給優(yōu)先級相同或者更高的線程。
2、sleep方法會將線程轉(zhuǎn)入阻塞狀態(tài),直到經(jīng)過阻塞時間才會轉(zhuǎn)入就緒狀態(tài)。而yield方法直接轉(zhuǎn)入就緒狀態(tài)。
3、sleep方法會拋出InterruptedException
異常,所以調(diào)用時需要顯示捕獲異常,yield方法不會拋出任何異常。
4、sleep方法比yield方法具有更多的移植性,通常不依靠yield方法控制并發(fā)線程執(zhí)行。
如果多個線程共同訪問1個對象中的實例變量,則有可能出現(xiàn)”非線程安全”
class SelfPrivateNum { private int num = 0; public void addI(String username) { try { if (username.equals("a")) { num = 100; System.out.println("a set over!"); Thread.sleep(2000); } else { num = 200; System.out.println("b set over!"); } System.out.println(username + " num=" + num); } catch (InterruptedException e) { e.printStackTrace(); } } } class ThreadAA extends Thread { private SelfPrivateNum numRef; public ThreadAA(SelfPrivateNum numRef) { super(); this.numRef = numRef; } @Override public void run() { super.run(); numRef.addI("a"); } } class ThreadBB extends Thread { private SelfPrivateNum numRef; public ThreadBB(SelfPrivateNum numRef) { super(); this.numRef = numRef; } @Override public void run() { super.run(); numRef.addI("b"); } } public class RunUnsafe { public static void main(String[] args) { SelfPrivateNum numRef = new SelfPrivateNum(); ThreadAA athread = new ThreadAA(numRef); athread.start(); ThreadBB bthread = new ThreadBB(numRef); bthread.start(); } }
synchronized
關(guān)鍵字來修飾某個方法。當(dāng)多個線程調(diào)用這個方法的時,以排隊的方式進(jìn)行處理。同步方法不具有繼承性。class SelfPrivateNum2 { private int num = 0; public synchronized void addI(String username) { try { if (username.equals("a")) { num = 100; System.out.println("a set over!"); Thread.sleep(2000); } else { num = 200; System.out.println("b set over!"); } System.out.println(username + " num=" + num); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
關(guān)鍵字synchronized取的是鎖都是對象鎖,而不是代碼或者是方法當(dāng)作鎖。當(dāng)多個線程訪問的是同一個對象的同步方法的時候是排隊的,而當(dāng)多個線程訪問多個對象的同步方法的時候運行的順序是異步的。
A線程先持有object對象的鎖,B線程如果調(diào)用object的synchronizaed類型的方法則需要等待,也就是同步。
臟讀
為了避免數(shù)據(jù)出現(xiàn)交叉的情況,使用synchronized關(guān)鍵字來進(jìn)行同步。雖然在賦值時進(jìn)行了同步,但是可能在取值的時候出現(xiàn)臟讀(dirtyRead)的現(xiàn)象。發(fā)生臟讀的情況是在讀取實例變量時。出現(xiàn)臟讀是應(yīng)為getValue方法不是同步方法,解決方法可以定義為同步方法。
//線程開始執(zhí)行同步代碼塊之前,必須先獲得對同步監(jiān)控器的鎖定 synchronized (Obj){ ……… //此處的代碼就是同步代碼塊 }
通常使用可能被并發(fā)訪問的共享資源充當(dāng)同步監(jiān)視器。
以下情況不會釋放同步鎖:
當(dāng)前線程的同步方法或代碼塊調(diào)用 Thread.sleep()
,Thread.yield()
方法來暫停當(dāng)前線程執(zhí)行
當(dāng)前線程的同步方法或代碼塊時,其他線程調(diào)用了該線程的suspend方法讓該線程掛起
LOCK鎖
Class A{ private final ReentrantLock lock= new ReentrantLock (); //需要保證線程安全的方法 public void m(){ //加鎖 lock.lock(); try{ …………… } finally{ lock.unlock(); } } }
同步方法的比較
1、同步方法和同步代碼塊使用與競爭資源相關(guān)的、隱式的同步監(jiān)視器,并且強制要求加鎖和釋放鎖要出現(xiàn)在同一個塊結(jié)構(gòu)中,而且當(dāng)獲取多個鎖的時候,他們必須按照相反的順序依次釋放。
2、Lock方法不僅可以使用與非結(jié)構(gòu)快中,還可以試圖中斷鎖和再次加鎖的功能。被Lock加鎖的代碼中還可以嵌套調(diào)用。
3、資源競爭不是很激烈的情況下,Synchronized的性能要優(yōu)于ReetrantLock,但是在資源競爭很激烈的情況下,Synchronized的性能會下降幾十倍。
Volatile關(guān)鍵字
強制性從公共堆棧中(存放實例)中取得修飾的變量的值,而不是從線程的私有數(shù)據(jù)棧中取得變量的值。不能保證不會出現(xiàn)臟讀的情況,需要用關(guān)鍵字synchronized
來解決。
ThreadLocal類
ThreadLocal在每個線程中對該變量會創(chuàng)建一個副本,即每個線程內(nèi)部都會有一個該變量,且在線程內(nèi)部任何地方都可以使用,線程之間互不影響。ThreadLocal提供資源的共享對象!
T get()
:返回此線程局部變量中當(dāng)前線程副本的值
void remove()
:刪除此線程局部變量中當(dāng)前副本的值
void set(T value)
:設(shè)置此線程局部變量中當(dāng)前線程副本的值
如果需要進(jìn)行多個線程之間共享資源,以達(dá)到線程之間的通信功能,就使用同步機制;如果僅僅需要隔離多個線程之間的共享沖突,可以使Threadlocal。
死鎖:當(dāng)兩個線程相互等待對象釋放同步監(jiān)視器的時候就會發(fā)生死鎖。
使用一種稱為資源排序的簡單技術(shù)可以輕易避免死鎖。
等待通知機制
方法wait()的作用是使當(dāng)前執(zhí)行代碼線程進(jìn)行等待,是Object類的方法,該方法用來將當(dāng)前線程置于“阻塞隊列”中,并在wait()所在的代碼處停止執(zhí)行,直到接到通知被喚醒。
在調(diào)用wait()
之前,線程必須持有該對象的對象級別鎖,只能在同步方法或者是同步塊中調(diào)用此方法。在執(zhí)行wait方法后,當(dāng)前線程釋放鎖。進(jìn)入和其他線程競爭重新獲得鎖。如果調(diào)用wait方法沒有持有鎖,則會拋出異常。
方法notify()用來通知那些可能等待該對象的對象鎖的其他線程,如果有多個線程等待,則由線程規(guī)劃器隨便選擇一個呈wait狀態(tài)的線程。
方法nofity()
也是在同步方法或者同步塊中調(diào)用,調(diào)用前同樣要獲得對象的對象級別所,否則拋出異常。在執(zhí)行notify方法后,當(dāng)前線程不會馬上釋放該對象鎖,要等到執(zhí)行notify方法的線程將程序執(zhí)行完才能會釋放鎖。
方法notifyAll()方法可以使正在等待隊列中等待同一共享資源的”全部”線程從等待狀態(tài)退出,進(jìn)入可運行狀態(tài)。
public class Test3 { //main方法中有三個等待線程,一個喚醒線程,一個喚醒線程只能喚醒一個等待線程,程序出現(xiàn)阻塞 public static void main(String[] args) throws InterruptedException { Object lock = new Object(); ThreadA a = new ThreadA(lock); new ThreadA(lock).start(); new ThreadA(lock).start(); new ThreadA(lock).start(); Thread.sleep(1000); NotifyThread notifyThread = new NotifyThread(lock); notifyThread.start(); } } class ThreadA extends Thread { private Object lock; public ThreadA(Object lock) { super(); this.lock = lock; } @Override public void run() { Service service = new Service(); service.testMethod(lock); } } class NotifyThread extends Thread { private Object lock; public NotifyThread(Object lock) { super(); this.lock = lock; } @Override public void run() { synchronized (lock) { //notify()只能喚醒一個線程,nofiyAll()喚醒所有的等待線程 lock.notify(); // lock.notifyAll(); } } } class Service { public void testMethod(Object lock) { try { synchronized (lock) { System.out.println("begin wait() ThreadName=" + Thread.currentThread().getName()); lock.wait(); System.out.println(" end wait() ThreadName=" + Thread.currentThread().getName()); } } catch (InterruptedException e) { e.printStackTrace(); } } }
在沒有使用synchronized關(guān)鍵字保證同步,而采用Lock的程序。Java提供了condition類來保持協(xié)調(diào)。Lock替代synchronized,Condition替代同步監(jiān)視器功能。
await
: 類似于wait。signal
:喚醒在此Lock對象上等待的單個線程,選擇是任意的。signalAll
:喚醒在此Lock對象上等待的所有線程,選擇是任意的。
public class Account { //顯示定義Lock對象 private final Lock lock = new ReentrantLock(); //獲得指定Lock對象對應(yīng)的條件變量 private final Condition cond = lock.newCondition(); private String accountNo; private double balance; //標(biāo)識賬戶中是否已經(jīng)存款的旗標(biāo) private boolean flag = false; public Account(){} public Account(String accountNo , double balance) { this.accountNo = accountNo; this.balance = balance; } public void setAccountNo(String accountNo) { this.accountNo = accountNo; } public String getAccountNo() { return this.accountNo; } public double getBalance() { return this.balance; } public void draw(double drawAmount) { //加鎖 lock.lock(); try { //如果賬戶中還沒有存入存款,該線程等待 while(!flag) { cond.await(); } //執(zhí)行取錢操作 System.out.println(Thread.currentThread().getName() + " 取錢:" + drawAmount); balance -= drawAmount; System.out.println("賬戶余額為:" + balance); //將標(biāo)識是否成功存入存款的旗標(biāo)設(shè)為false flag = false; //喚醒該Lock對象對應(yīng)的其他線程 cond.signalAll(); } catch (InterruptedException ex) { ex.printStackTrace(); } //使用finally塊來確保釋放鎖 finally { lock.unlock(); } } public void deposit(double depositAmount) { lock.lock(); try { //如果賬戶中已經(jīng)存入了存款,該線程等待 while(flag) { cond.await(); } //執(zhí)行存款操作 System.out.println(Thread.currentThread().getName() + " 存款:" + depositAmount); balance += depositAmount; System.out.println("賬戶余額為:" + balance); //將標(biāo)識是否成功存入存款的旗標(biāo)設(shè)為true flag = true; //喚醒該Lock對象對應(yīng)的其他線程 cond.signalAll(); } catch (InterruptedException ex) { ex.printStackTrace(); } //使用finally塊來確保釋放鎖 finally { lock.unlock(); } } public int hashCode() { return accountNo.hashCode(); } public boolean equals(Object obj) { if (obj != null && obj.getClass() == Account.class) { Account target = (Account)obj; return target.getAccountNo().equals(accountNo); } return false; } }
使用notify()/notifyAll()方法進(jìn)行通知時,被通知的線程卻是JVM隨機選擇的。當(dāng)notifyAll()通知所有WAITING線程,沒有選擇權(quán),會出現(xiàn)相當(dāng)大的效率問題。但是ReentrantLock結(jié)合Condition類可以”選擇性通知”。Condition可以實現(xiàn)喚醒部分指定線程,這樣有助于程序運行的效率。
從JDK1.5之后,Java提供了Callable接口,實際上就是Runnable接口的增強版。提供call方法作為線程執(zhí)行體,但是功能更加強大。
Callable接口不是Runnable接口,不能直接作為Thread的target,有返回值得call方法也不能直接運行。這里需要一個包裝器Future。
import java.util.concurrent.*; class RtnThread implements Callable<Integer> { //實現(xiàn)call方法,作為線程執(zhí)行體 public Integer call() { int sum = 0; int i=0; for ( ; i < 10 ; i++ ) { System.out.println(Thread.currentThread().getName()+ " 的循環(huán)變量i的值:" + i); sum+=i; } //call()方法可以有返回值 return sum; } } public class CallableTest { public static void main(String[] args) { //創(chuàng)建Callable對象 RtnThread rt = new RtnThread(); //使用FutureTask來包裝Callable對象 FutureTask<Integer> task = new FutureTask<Integer>(rt); for (int i = 0 ; i < 10 ; i++) { System.out.println(Thread.currentThread().getName() + " 的循環(huán)變量i的值:" + i); if (i == 5) { //實質(zhì)還是以Callable對象來創(chuàng)建、并啟動線程 new Thread(task , "有返回值的線程").start(); } } try { //獲取線程返回值 System.out.println("子線程的返回值:" + task.get()); } catch (Exception ex) { ex.printStackTrace(); } } }
import java.util.concurrent.*; //實現(xiàn)Runnable接口來定義一個簡單的 class TestThread implements Runnable { public void run() { for (int i = 0; i < 10 ; i++ ) { System.out.println(Thread.currentThread().getName() + "的i值為:" + i); } } } public class ThreadPoolTest { public static void main(String[] args) { //創(chuàng)建一個具有固定線程數(shù)(6)的線程池 ExecutorService pool = Executors.newFixedThreadPool(6); //向線程池中提交3個線程 pool.execute(new TestThread()); Future f1=pool.submit(new TestThread()); Future f2=pool.submit(new TestThread()); Future<Integer> f3=pool.submit(new RtnThread()); try { if(f1.get()==null&&f2.get()==null&&f3.get()!=null){ System.out.println("執(zhí)行完畢!"); System.out.println(f3.get()); } //獲取線程返回值 } catch (Exception ex) { ex.printStackTrace(); } //關(guān)閉線程池 pool.shutdown(); } }
更多java相關(guān)內(nèi)容感興趣的讀者可查看本站專題:《Java進(jìn)程與線程操作技巧總結(jié)》、《Java數(shù)據(jù)結(jié)構(gòu)與算法教程》、《Java操作DOM節(jié)點技巧總結(jié)》、《Java文件與目錄操作技巧匯總》和《Java緩存操作技巧匯總》
希望本文所述對大家java程序設(shè)計有所幫助。
新聞名稱:JAVA多線程編程實例詳解
URL網(wǎng)址:http://bm7419.com/article0/psscoo.html
成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián),為您提供企業(yè)建站、搜索引擎優(yōu)化、微信小程序、網(wǎng)站建設(shè)、網(wǎng)站營銷、網(wǎng)站策劃
聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權(quán)請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)