多線程java實例

發布時間: 2023-03-13 05:31:19

① java多線程有哪些實際的應用場景

場景一:一個業務邏輯有很多次的循環，每次循環之間沒有影響，比如驗證1萬條url路徑是否存在，正常情況要循環1萬次，逐個去驗證每一條URL，這樣效率會很低，假設驗證一條需要1分鍾，總共就需要1萬分鍾，有點恐怖。這時可以用多線程，將1萬條URL分成50等份，開50個線程，沒個線程只需驗證200條，這樣所有的線程執行完是遠小於1萬分鍾的。

場景二:需要知道一個任務的執行進度，比如我們常看到的進度條，實現方式可以是在任務中加入一個整型屬性變數(這樣不同方法可以共享)，任務執行一定程度就給變數值加1，另外開一個線程按時間間隔不斷去訪問這個變數，並反饋給用戶。

總之使用多線程就是為了充分利用cpu的資源，提高程序執行效率，當你發現一個業務邏輯執行效率特別低，耗時特別長，就可以考慮使用多線程。不過CPU執行哪個線程的時間和順序是不確定的，即使設置了線程的優先順序，因此使用多線程的風險也是比較大的，會出現很多預料不到的問題，一定要多熟悉概念，多構造不同的場景去測試才能夠掌握!

我有一個微信公眾號，每天都會分享一些Java相關的干貨文章，還有一些學習資源。
如果你喜歡我的分享，可以用微信搜索「Java團長」或者「javatuanzhang」關注。

② 一個簡單java多線程的示例

想了解深入一點可以去了解一下操作系統進程/線程，他們是按照一個時間片運行的，也就是說在A線程的時間片內，A線程已經運行完畢，如果A線程在時間片內還沒跑完，那麼A線程就暫停，讓B線程跑他的時間片，所以線程的問題比較難測，因為現代的計算機運行速度相當快，如果要看效果，也可以讓A線程阻塞一下

③ 在Java 中多線程的實現方法有哪些，如何使用

Java多線程的創建及啟動

Java中線程的創建常見有如三種基本形式

1.繼承Thread類，重寫該類的run()方法。

復制代碼

1 class MyThread extends Thread {

3 private int i = 0;

5 @Override

6 public void run() {

7 for (i = 0; i < 100; i++) {

8 System.out.println(Thread.currentThread().getName() + " " + i);

9 }

10 }

11 }

復制代碼

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Thread myThread1 = new MyThread(); // 創建一個新的線程 myThread1 此線程進入新建狀態

8 Thread myThread2 = new MyThread(); // 創建一個新的線程 myThread2 此線程進入新建狀態

9 myThread1.start(); // 調用start()方法使得線程進入就緒狀態

10 myThread2.start(); // 調用start()方法使得線程進入就緒狀態

11 }

12 }

13 }

14 }

復制代碼

如上所示，繼承Thread類，通過重寫run()方法定義了一個新的線程類MyThread，其中run()方法的方法體代表了線程需要完成的任務，稱之為線程執行體。當創建此線程類對象時一個新的線程得以創建，並進入到線程新建狀態。通過調用線程對象引用的start()方法，使得該線程進入到就緒狀態，此時此線程並不一定會馬上得以執行，這取決於CPU調度時機。

2.實現Runnable介面，並重寫該介面的run()方法，該run()方法同樣是線程執行體，創建Runnable實現類的實例，並以此實例作為Thread類的target來創建Thread對象，該Thread對象才是真正的線程對象。

復制代碼

1 class MyRunnable implements Runnable {

2 private int i = 0;

4 @Override

5 public void run() {

6 for (i = 0; i < 100; i++) {

7 System.out.println(Thread.currentThread().getName() + " " + i);

8 }

9 }

10 }

復制代碼

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable(); // 創建一個Runnable實現類的對象

8 Thread thread1 = new Thread(myRunnable); // 將myRunnable作為Thread target創建新的線程

9 Thread thread2 = new Thread(myRunnable);

10 thread1.start(); // 調用start()方法使得線程進入就緒狀態

11 thread2.start();

12 }

13 }

14 }

15 }

復制代碼

相信以上兩種創建新線程的方式大家都很熟悉了，那麼Thread和Runnable之間到底是什麼關系呢？我們首先來看一下下面這個例子。

復制代碼

1 public class ThreadTest {

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable();

8 Thread thread = new MyThread(myRunnable);

9 thread.start();

10 }

11 }

12 }

13 }

15 class MyRunnable implements Runnable {

16 private int i = 0;

18 @Override

19 public void run() {

20 System.out.println("in MyRunnable run");

21 for (i = 0; i < 100; i++) {

22 System.out.println(Thread.currentThread().getName() + " " + i);

23 }

24 }

25 }

27 class MyThread extends Thread {

29 private int i = 0;

31 public MyThread(Runnable runnable){

32 super(runnable);

33 }

35 @Override

36 public void run() {

37 System.out.println("in MyThread run");

38 for (i = 0; i < 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 }

41 }

42 }

復制代碼

同樣的，與實現Runnable介面創建線程方式相似，不同的地方在於

1 Thread thread = new MyThread(myRunnable);

那麼這種方式可以順利創建出一個新的線程么？答案是肯定的。至於此時的線程執行體到底是MyRunnable介面中的run()方法還是MyThread類中的run()方法呢？通過輸出我們知道線程執行體是MyThread類中的run()方法。其實原因很簡單，因為Thread類本身也是實現了Runnable介面，而run()方法最先是在Runnable介面中定義的方法。

1 public interface Runnable {

3 public abstract void run();

5 }

我們看一下Thread類中對Runnable介面中run()方法的實現：

復制代碼

@Override

public void run() {

if (target != null) {

target.run();

}

復制代碼

也就是說，當執行到Thread類中的run()方法時，會首先判斷target是否存在，存在則執行target中的run()方法，也就是實現了Runnable介面並重寫了run()方法的類中的run()方法。但是上述給到的列子中，由於多態的存在，根本就沒有執行到Thread類中的run()方法，而是直接先執行了運行時類型即MyThread類中的run()方法。

3.使用Callable和Future介面創建線程。具體是創建Callable介面的實現類，並實現clall()方法。並使用FutureTask類來包裝Callable實現類的對象，且以此FutureTask對象作為Thread對象的target來創建線程。

看著好像有點復雜，直接來看一個例子就清晰了。

復制代碼

1 public class ThreadTest {

3 public static void main(String[] args) {

5 Callable<Integer> myCallable = new MyCallable(); // 創建MyCallable對象

6 FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask來包裝MyCallable對象

8 for (int i = 0; i < 100; i++) {

9 System.out.println(Thread.currentThread().getName() + " " + i);

10 if (i == 30) {

11 Thread thread = new Thread(ft); //FutureTask對象作為Thread對象的target創建新的線程

12 thread.start(); //線程進入到就緒狀態

13 }

14 }

16 System.out.println("主線程for循環執行完畢..");

18 try {

19 int sum = ft.get(); //取得新創建的新線程中的call()方法返回的結果

20 System.out.println("sum = " + sum);

21 } catch (InterruptedException e) {

22 e.printStackTrace();

23 } catch (ExecutionException e) {

24 e.printStackTrace();

25 }

27 }

28 }

31 class MyCallable implements Callable<Integer> {

32 private int i = 0;

34 // 與run()方法不同的是，call()方法具有返回值

35 @Override

36 public Integer call() {

37 int sum = 0;

38 for (; i < 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 sum += i;

41 }

42 return sum;

43 }

45 }

復制代碼

首先，我們發現，在實現Callable介面中，此時不再是run()方法了，而是call()方法，此call()方法作為線程執行體，同時還具有返回值！在創建新的線程時，是通過FutureTask來包裝MyCallable對象，同時作為了Thread對象的target。那麼看下FutureTask類的定義：

1 public class FutureTask<V> implements RunnableFuture<V> {

3 //....

5 }

1 public interface RunnableFuture<V> extends Runnable, Future<V> {

3 void run();

5 }

於是，我們發現FutureTask類實際上是同時實現了Runnable和Future介面，由此才使得其具有Future和Runnable雙重特性。通過Runnable特性，可以作為Thread對象的target，而Future特性，使得其可以取得新創建線程中的call()方法的返回值。

執行下此程序，我們發現sum = 4950永遠都是最後輸出的。而「主線程for循環執行完畢..」則很可能是在子線程循環中間輸出。由CPU的線程調度機制，我們知道，「主線程for循環執行完畢..」的輸出時機是沒有任何問題的，那麼為什麼sum =4950會永遠最後輸出呢？

原因在於通過ft.get()方法獲取子線程call()方法的返回值時，當子線程此方法還未執行完畢，ft.get()方法會一直阻塞，直到call()方法執行完畢才能取到返回值。

上述主要講解了三種常見的線程創建方式，對於線程的啟動而言，都是調用線程對象的start()方法，需要特別注意的是：不能對同一線程對象兩次調用start()方法。

你好，本題已解答,如果滿意

請點右下角「採納答案」。

④ java多線程有幾種實現方法線程之間如何同步

一、為什麼要線程同步

因為當我們有多個線程要同時訪問一個變數或對象時，如果這些線程中既有讀又有寫操作時，就會導致變數值或對象的狀態出現混亂，從而導致程序異常。舉個例子，如果一個銀行賬戶同時被兩個線程操作，一個取100塊，一個存錢100塊。假設賬戶原本有0塊，如果取錢線程和存錢線程同時發生，會出現什麼結果呢？取錢不成功，賬戶余額是100.取錢成功了，賬戶余額是0.那到底是哪個呢？很難說清楚。因此多線程同步就是要解決這個問題。

二、不同步時的代碼

Bank.Java

packagethreadTest;

/**
*@authorww
*
*/
publicclassBank{

	privateintcount=0;//賬戶余額
	
	//存錢
	publicvoidaddMoney(intmoney){
		count+=money;
		System.out.println(System.currentTimeMillis()+"存進："+money);
	}
	
	//取錢
	publicvoidsubMoney(intmoney){
		if(count-money<0){
			System.out.println("余額不足");
			return;
		}
		count-=money;
		System.out.println(+System.currentTimeMillis()+"取出："+money);
	}
	
	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count);
	}
}

SyncThreadTest.java


packagethreadTest;


publicclassSyncThreadTest{

	publicstaticvoidmain(Stringargs[]){
		finalBankbank=newBank();
		
		Threadtadd=newThread(newRunnable(){
			
			@Override
			publicvoidrun(){
				//TODOAuto-generatedmethodstub
				while(true){
					try{
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						//TODOAuto-generatedcatchblock
						e.printStackTrace();
					}
					bank.addMoney(100);
					bank.lookMoney();
					System.out.println("
");
					
				}
			}
		});
		
		Threadtsub=newThread(newRunnable(){
			
			@Override
			publicvoidrun(){
				//TODOAuto-generatedmethodstub
				while(true){
					bank.subMoney(100);
					bank.lookMoney();
					System.out.println("
");
					try{
						Thread.sleep(1000);
					}catch(InterruptedExceptione){
						//TODOAuto-generatedcatchblock
						e.printStackTrace();
					}	
				}
			}
		});
		tsub.start();
		
		tadd.start();
	}
	
	

}


余額不足
賬戶余額：0


余額不足
賬戶余額：100


1441790503354存進：100
賬戶余額：100


1441790504354存進：100
賬戶余額：100


1441790504354取出：100
賬戶余額：100


1441790505355存進：100
賬戶余額：100


1441790505355取出：100
賬戶余額：100

三、使用同步時的代碼

（1）同步方法：

即有synchronized關鍵字修飾的方法。由於java的每個對象都有一個內置鎖，當用此關鍵字修飾方法時，內置鎖會保護整個方法。在調用該方法前，需要獲得內置鎖，否則就處於阻塞狀態。

修改後的Bank.java


packagethreadTest;

/**
*@authorww
*
*/
publicclassBank{

	privateintcount=0;//賬戶余額
	
	//存錢
	(intmoney){
		count+=money;
		System.out.println(System.currentTimeMillis()+"存進："+money);
	}
	
	//取錢
	(intmoney){
		if(count-money<0){
			System.out.println("余額不足");
			return;
		}
		count-=money;
		System.out.println(+System.currentTimeMillis()+"取出："+money);
	}
	
	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count);
	}
}

再看看運行結果：


余額不足
賬戶余額：0


余額不足
賬戶余額：0


1441790837380存進：100
賬戶余額：100


1441790838380取出：100
賬戶余額：0
1441790838380存進：100
賬戶余額：100
1441790839381取出：100
賬戶余額：0

瞬間感覺可以理解了吧。

註： synchronized關鍵字也可以修飾靜態方法，此時如果調用該靜態方法，將會鎖住整個類

（2）同步代碼塊

即有synchronized關鍵字修飾的語句塊。被該關鍵字修飾的語句塊會自動被加上內置鎖，從而實現同步

Bank.java代碼如下：


packagethreadTest;

/**
*@authorww
*
*/
publicclassBank{

	privateintcount=0;//賬戶余額
	
	//存錢
	publicvoidaddMoney(intmoney){
		
		synchronized(this){
			count+=money;
		}
		System.out.println(System.currentTimeMillis()+"存進："+money);
	}
	
	//取錢
	publicvoidsubMoney(intmoney){
		
		synchronized(this){
			if(count-money<0){
				System.out.println("余額不足");
				return;
			}
			count-=money;
		}
		System.out.println(+System.currentTimeMillis()+"取出："+money);
	}
	
	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count);
	}
}

運行結果如下：

余額不足
賬戶余額：0


1441791806699存進：100
賬戶余額：100


1441791806700取出：100
賬戶余額：0


1441791807699存進：100
賬戶余額：100

效果和方法一差不多。

註：同步是一種高開銷的操作，因此應該盡量減少同步的內容。通常沒有必要同步整個方法，使用synchronized代碼塊同步關鍵代碼即可。

（3）使用特殊域變數(volatile)實現線程同步

a.volatile關鍵字為域變數的訪問提供了一種免鎖機制
b.使用volatile修飾域相當於告訴虛擬機該域可能會被其他線程更新
c.因此每次使用該域就要重新計算，而不是使用寄存器中的值
d.volatile不會提供任何原子操作，它也不能用來修飾final類型的變數

Bank.java代碼如下：


packagethreadTest;

/**
*@authorww
*
*/
publicclassBank{

	privatevolatileintcount=0;//賬戶余額

	//存錢
	publicvoidaddMoney(intmoney){

		count+=money;
		System.out.println(System.currentTimeMillis()+"存進："+money);
	}

	//取錢
	publicvoidsubMoney(intmoney){

		if(count-money<0){
			System.out.println("余額不足");
			return;
		}
		count-=money;
		System.out.println(+System.currentTimeMillis()+"取出："+money);
	}

	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count);
	}
}

運行效果怎樣呢？


余額不足
賬戶余額：0


余額不足
賬戶余額：100


1441792010959存進：100
賬戶余額：100


1441792011960取出：100
賬戶余額：0


1441792011961存進：100
賬戶余額：100

是不是又看不懂了，又亂了。這是為什麼呢？就是因為volatile不能保證原子操作導致的，因此volatile不能代替synchronized。此外volatile會組織編譯器對代碼優化，因此能不使用它就不適用它吧。它的原理是每次要線程要訪問volatile修飾的變數時都是從內存中讀取，而不是存緩存當中讀取，因此每個線程訪問到的變數值都是一樣的。這樣就保證了同步。

（4）使用重入鎖實現線程同步

在JavaSE5.0中新增了一個java.util.concurrent包來支持同步。ReentrantLock類是可重入、互斥、實現了Lock介面的鎖，它與使用synchronized方法和快具有相同的基本行為和語義，並且擴展了其能力。
ReenreantLock類的常用方法有：
ReentrantLock() : 創建一個ReentrantLock實例
lock() : 獲得鎖
unlock() : 釋放鎖
註：ReentrantLock()還有一個可以創建公平鎖的構造方法，但由於能大幅度降低程序運行效率，不推薦使用
Bank.java代碼修改如下：


packagethreadTest;

importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;

/**
*@authorww
*
*/
publicclassBank{

	privateintcount=0;//賬戶余額
	
	//需要聲明這個鎖
privateLocklock=newReentrantLock();

	//存錢
	publicvoidaddMoney(intmoney){
		lock.lock();//上鎖
		try{
		count+=money;
		System.out.println(System.currentTimeMillis()+"存進："+money);
		
		}finally{
			lock.unlock();//解鎖
		}
	}

	//取錢
	publicvoidsubMoney(intmoney){
		lock.lock();
		try{
			
		if(count-money<0){
			System.out.println("余額不足");
			return;
		}
		count-=money;
		System.out.println(+System.currentTimeMillis()+"取出："+money);
		}finally{
			lock.unlock();
		}
	}

	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count);
	}
}

運行效果怎麼樣呢？


余額不足
賬戶余額：0


余額不足
賬戶余額：0


1441792891934存進：100
賬戶余額：100


1441792892935存進：100
賬戶余額：200


1441792892954取出：100
賬戶余額：100

效果和前兩種方法差不多。

如果synchronized關鍵字能滿足用戶的需求，就用synchronized，因為它能簡化代碼。如果需要更高級的功能，就用ReentrantLock類，此時要注意及時釋放鎖，否則會出現死鎖，通常在finally代碼釋放鎖

（5）使用局部變數實現線程同步

Bank.java代碼如下：


packagethreadTest;


/**
*@authorww
*
*/
publicclassBank{

	privatestaticThreadLocal<Integer>count=newThreadLocal<Integer>(){

		@Override
		protectedIntegerinitialValue(){
			//TODOAuto-generatedmethodstub
			return0;
		}
		
	};
	

	//存錢
	publicvoidaddMoney(intmoney){
		count.set(count.get()+money);
		System.out.println(System.currentTimeMillis()+"存進："+money);
		
	}

	//取錢
	publicvoidsubMoney(intmoney){
		if(count.get()-money<0){
			System.out.println("余額不足");
			return;
		}
		count.set(count.get()-money);
		System.out.println(+System.currentTimeMillis()+"取出："+money);
	}

	//查詢
	publicvoidlookMoney(){
		System.out.println("賬戶余額："+count.get());
	}
}

運行效果：


余額不足
賬戶余額：0


余額不足
賬戶余額：0


1441794247939存進：100
賬戶余額：100


余額不足
1441794248940存進：100
賬戶余額：0


賬戶余額：200


余額不足
賬戶余額：0


1441794249941存進：100
賬戶余額：300

看了運行效果，一開始一頭霧水，怎麼只讓存，不讓取啊？看看ThreadLocal的原理：

如果使用ThreadLocal管理變數，則每一個使用該變數的線程都獲得該變數的副本，副本之間相互獨立，這樣每一個線程都可以隨意修改自己的變數副本，而不會對其他線程產生影響。現在明白了吧，原來每個線程運行的都是一個副本，也就是說存錢和取錢是兩個賬戶，知識名字相同而已。所以就會發生上面的效果。

ThreadLocal與同步機制
a.ThreadLocal與同步機制都是為了解決多線程中相同變數的訪問沖突問題

b.前者採用以"空間換時間"的方法，後者採用以"時間換空間"的方式

⑤ java 如何實現多線程

線程間的通信方式
同步
這里講的同步是指多個線程通過synchronized關鍵字這種方式來實現線程間的通信。
參考示例：
public class MyObject {
synchronized public void methodA() {
//do something....
}
synchronized public void methodB() {
//do some other thing
}
}
public class ThreadA extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodA();
}
}
public class ThreadB extends Thread {
private MyObject object;
//省略構造方法
@Override
public void run() {
super.run();
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
//線程A與線程B 持有的是同一個對象:object
ThreadA a = new ThreadA(object);
ThreadB b = new ThreadB(object);
a.start();
b.start();
}
}
由於線程A和線程B持有同一個MyObject類的對象object，盡管這兩個線程需要調用不同的方法，但是它們是同步執行的，比如：線程B需要等待線程A執行完了methodA()方法之後，它才能執行methodB()方法。這樣，線程A和線程B就實現了通信。
這種方式，本質上就是「共享內存」式的通信。多個線程需要訪問同一個共享變數，誰拿到了鎖（獲得了訪問許可權），誰就可以執行。

⑥ java 多線程的例子

多線程實際上就是多個線程同時運行，至於那個先完成是不能確定的。

* @author Rollen-Holt 實現Runnable介面

* */

class hello implements Runnable {

public hello() {

}

public hello(String name) {

this.name = name;

}

public void run() {

for (int i = 0; i < 5; i++) {

System.out.println(name + "運行 " + i);

}

public static void main(String[] args) {

hello h1=new hello("線程A");

Thread demo= new Thread(h1);

hello h2=new hello("線程B");

Thread demo1=new Thread(h2);

demo.start();

demo1.start();

}

private String name;

}

可能運行結果：

⑦ Java多線程編程

作者 natrium 一理解多線程多線程是這樣一種機制它允許在程序中並發執行多個指令流每個指令流都稱為一個線程彼此間互相獨立線程又稱為輕量級進程它和進程一樣擁有獨立的執行控制由操作系統負責調度區別在於線程沒有獨立的存儲空間而是和所屬進程中的其它線程共享一個存儲空間這使得線程間的通信遠較進程簡單多個線程的執行是並發的也就是在邏輯上同時而不管是否是物理上的同時如果系統只有一個CPU 那麼真正的同時是不可能的但是由於CPU的速度非常快用戶感覺不到其中的區別因此我們也不用關心它只需要設想各個線程是同時執行即可多線程和傳統的單線程在程序設計上最大的區別在於由於各個線程的控制流彼此獨立使得各個線程之間的代碼是亂序執行的由此帶來的線程調度同步等問題將在以後探討二在Java中實現多線程我們不妨設想為了創建一個新的線程我們需要做些什麼？很顯然我們必須指明這個線程所要執行的代碼而這就是在Java中實現多線程我們所需要做的一切！真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言 Java提供了類 java lang Thread 來方便多線程編程這個類提供了大量的方法來方便我們控制自己的各個線程我們以後的討論都將圍繞這個類進行那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類 Thread 類最重要的方法是 run() 它為Thread 類的方法 start() 所調用提供我們的線程所要執行的代碼為了指定我們自己的代碼只需要覆蓋它！方法一繼承 Thread 類覆蓋方法 run() 我們在創建的 Thread 類的子類中重寫 run() 加入線程所要執行的代碼即可下面是一個例子 public class MyThread extends Thread {int count= number;public MyThread(int num) {number = num;System out println( 創建線程 + number);}public void run() {while(true) {System out println( 線程 + number + :計數 + count);if(++count== ) return;}}public static void main(String args[]) {for(int i = ; i < 5; i++) new MyThread(i+1).start();}}這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？我們不妨來探索一種新的方法：我們不創建 Thread 類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。.WINgWIT.但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。那麼如何限制這個類必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）Java 提供了介面 java.lang.Runnable 來支持這種方法。方法二：實現 Runnable 介面Runnable 介面只有一個方法 run()，我們聲明自己的類實現 Runnable 介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對線程的支持，我們還必須創建 Thread 類的實例，這一點通過 Thread 類的構造函數public Thread(Runnable target);來實現。下面是一個例子：public class MyThread implements Runnable {int count= 1, number;public MyThread(int num) {number = num;System.out.println("創建線程 " + number);}public void run() {while(true) {System.out.println("線程 " + number + ":計數 " + count);if(++count== 6) return;} }public static void main(String args[]) {for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();}}嚴格地說，創建 Thread 子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。綜上所述，兩種方法各有千秋，大家可以靈活運用。下面讓我們一起來研究一下多線程使用中的一些問題。三：線程的四種狀態1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。四：線程的優先順序線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。五：線程的同步由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下： synchronized(syncObject) {//允許訪問控制的代碼}synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。六：線程的阻塞為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。1. sleep() 方法：sleep() 允許指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後 lishixin/Article/program/Java/gj/201311/27622

閱讀全文

熱點內容

動態規劃01背包演算法發布：2024-11-05 22:17:40 瀏覽：849

nasm編譯器如何安裝發布：2024-11-05 22:01:13 瀏覽：181

登錄密碼在微信的哪裡發布：2024-11-05 22:00:29 瀏覽：739

c防止反編譯工具發布：2024-11-05 21:56:14 瀏覽：247

安卓虛擬機怎麼用發布：2024-11-05 21:52:48 瀏覽：344

php時間搜索發布：2024-11-05 20:58:36 瀏覽：479

燕山大學編譯原理期末考試題發布：2024-11-05 20:13:54 瀏覽：528

華為電腦出現臨時伺服器發布：2024-11-05 20:05:08 瀏覽：408

斗戰神免費挖礦腳本發布：2024-11-05 19:53:25 瀏覽：665

網吧伺服器分別是什麼發布：2024-11-05 19:45:32 瀏覽：392

多線程java實例

與多線程java實例相關的資訊