執行緒的基本概念

執行緒是在邏輯上等同於作業系統中說的程序，是程序的細分。比如我們使用同一個軟體同時對電腦進行體檢和防毒的時候，我們就是開啟了那個軟體的程序的兩個執行緒，在邏輯上這兩個執行緒是同時被cpu執行的。

執行緒的生命週期

執行緒的生命週期分為建立，就緒，執行，阻塞和死亡，當我們時候start（）方法的時候就是建立一個執行緒，當這個執行緒所有資源都準備就緒，就差cpu執行的時候那麼就進入就緒佇列等待，當獲得cpu時間片的時候就處於執行週期，倘若執行緒時間片用完而任務沒有完成的話就會再次進入就緒佇列排隊等待，執行緒任務完成了之後就會被殺掉，在執行過程中被掛起就會進入阻塞佇列，在阻塞佇列中的執行緒被喚醒後就會進入就緒佇列繼續等待cpu時間片。

java中實現多執行緒的兩種方式

1.繼承Runnable介面實現多執行緒

Runnable介面的程式碼資訊如下

//  (version 10 : 54.0, no super bit)
@java.lang.FunctionalInterface
public abstract interface java.lang.Runnable {
  
  // Method descriptor #7 ()V
  public abstract void run();

}

當我們寫一個類繼承Runnable介面的時候一定要實現run方法，這個run方法就是我們使用多執行緒的時候想要做的事。

2.繼承Thread類實現多執行緒

Thread類實際上繼承了Runnable介面，也就是說我們在繼承Thread類的時候也要重寫run方法，實際上兩種方法的原理是一樣。

例項，繼承Thread類實現兩個執行緒分別列印1-100的奇數和1-100的偶數

package Thread;

class subthread1 extends Thread{
	public void run() {
		for(int i=1;i<=100;i++) {
			if(i%2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}
		
class subthread2 extends Thread{
	public void run() {
		for(int i=1;i<=100;i++) {
			if(i%2!=0) {
				System.out.println(Thread.currentThread().getName()+":"+i);
			}
		}
	}
}

public class TestThread {
	public static void main(String [] args) {
		subthread1 st1 = new subthread1();
		subthread2 st2 = new subthread2();
		st1.start();
		st2.start();
	}
}
 

執行緒死鎖的基本概念及執行緒同步

當兩個執行緒同時都握有對方所需的資源的時候，就進入了死鎖狀態，即兩個執行緒互相無限期等待。

比如下面這個程式就會產生死鎖。

package Thread;

public class TestDeadLock {
	static StringBuffer sb1 = new StringBuffer();
	static StringBuffer sb2 = new StringBuffer();
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Thread() {
			public void run() {
				synchronized(sb1) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					sb1.append("A");
					synchronized(sb2) {
						sb2.append("B");
						System.out.println(sb1);
						System.out.println(sb2);
					}
				}
			}
		}.start();
		
		new Thread() {
			public void run() {
				synchronized(sb2) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					sb1.append("C");
					synchronized(sb1) {
						sb2.append("D");
						System.out.println(sb1);
						System.out.println(sb2);
					}
				}
			}
		}.start();
	}

}

我們通常採用執行緒同步來解決死鎖問題。

使用synchronized關鍵字標註的方法就是支援程序同步的方法，它的形參可以是任何一個物件，一個物件代表了一把鎖，也就是說同一個物件代表了同一把鎖。

如上面一段程式碼所示，synchronized也可以用大括號來單獨修飾一段程式碼。

在上面的程式碼中，執行緒1握有鎖sb1，等待sb2；執行緒2握有sb2，等待sb1。他們互相都在等在對方暫時不會放棄的資源，就產生了死鎖。

死鎖的一個解決方法

我們可以用wait（），notify（）和notifyAll（）三個問題來避免死鎖的產生。這三個方法都來自與Object類。

wait（）方法可以將當前執行緒掛起，notify（）方法喚醒阻塞佇列中優先順序最高的執行緒進入就緒佇列，notifyAll（）喚醒所有阻塞佇列中的執行緒進入就緒佇列。

生產者消費者問題

package Thread;
/*
 * 生產者producer將產品交給店員clerk，然後店員將產品交給顧客customer
 */
class Clerk{
	int number ; //表示產品數量(預設訪問模式，只允許同一個包進行訪問)
	public synchronized void pro() {
		if(number >= 20) {
			//如果產品大於等於20，將生產者執行緒掛起
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		else {
			number++;
			System.out.println(Thread.currentThread().getName()+"生產了"+number+"個產品");
			notify();
		}
	}
	public synchronized void con() {
		if(number <= 0) {
			//如果產品小於等於0則將消費者執行緒掛起
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		else {
			System.out.println(Thread.currentThread().getName()+"消費了"+number+"個產品");
			number--;
			notify();
		}
	}
}

class Producer implements Runnable{
	Clerk clerk;
	public Producer(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		while(true) {
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			clerk.pro();
		}
	}
}

class Customer1 implements Runnable{
	Clerk clerk;
	public Customer1(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		while(true) {
		try {
			Thread.currentThread().sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		clerk.con();
		}
	}
}

public class TestProducerandcustomer {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Clerk clerk = new Clerk();
		Producer p1 = new Producer(clerk);
		Customer1 c1 = new Customer1(clerk);
		Thread t1 = new Thread(p1);
		Thread t2 = new Thread(p1);
		Thread t3 = new Thread(c1);
		t1.setName("生產者1");
		t2.setName("生產者2");
		t3.setName("消費者1");
		t1.start();
		t2.start();
		t3.start();
	}

}