Day12-Java

文章目錄

Day12-Java
- - 1、多執行緒
  - - - 1.1 多執行緒的基本概念
      - 1.2 多執行緒的實作
      - 1.3 繼承Thread類實作多執行緒
      - 1.4 Runnable介面實作多執行緒
      - 1.5 Thread類和Runnable介面實作多執行緒的區別
      - 1.6 執行緒的操作狀態
      - 1.7 Callable實作多執行緒
      - 1.8 執行緒命名和取得
      - 1.9 執行緒的休眠
      - 1.10 執行緒的優先級
      - 1.11 執行緒的同步與死鎖
      - 1.12 死鎖
    - 綜合案例
    - - 1.解決資料錯位問題：依靠同步解決
      - 2.解決資料的重復設定和重復取出
  - 面試題：請解釋sleep()和wait()的區別？

1、多執行緒

要使用多執行緒必須有一個前提，有一個執行緒的執行主類，從多執行緒開始，Java正式進入到應用部分，而對于多執行緒的開發，從JavaEE上表現的并不是特別多，但是在Android開發之中使用較多，并且需要提醒的是，鄙視面試的程序之中，多執行緒所問道的問題是最多的，

1.1 多執行緒的基本概念

如果要想解釋多執行緒，那么首先應該從單執行緒開始講起，最早的DOS系統有一個最大的特征：一旦電腦出現了病毒，電腦會立刻死機，因為傳統DOS系統屬于單行程的處理方式，即：在同一個時間段上只能有一個程式執行，后來到了windows時代，電腦即使（非致命）存在了病毒，那么也可以正常使用，只是滿了一些而已，因為windows屬于多行程的處理操作，但是這個時候的資源依然只有一塊，所以在同一時間段上會有多個程式共同執行，而在一個時間點上只能有一個程式在執行，多執行緒實在一個行程基礎之上的進一步劃分，因為行程的啟動所消耗的時間是非常長的，所以在行程之上的進一步劃分就變得非常重要，而且性能也會有所提高，

所有的執行緒一定要依附于行程才能夠存在，那么行程一旦消失了，執行緒也一定會消失，但反過來不一定，而Java是為數不多的支持多執行緒的開發語言之一，

1.2 多執行緒的實作

在Java之中，如果要想實作多執行緒的程式，就必須依靠一個執行緒的主體類（叫好比主類的概念一樣，表示的是一個執行緒的主類），但是這個執行緒的主體類在定義的時候也需要有一些特殊的要求，這個類可以繼承Thread類或實作Runnable介面來完成定義，

1.3 繼承Thread類實作多執行緒

Java.lang.Thread是一個執行緒操作的核心類負責執行緒操作的類，任何類只需要繼承了Thread類就可以成為一個執行緒的主類，但是既然是主類必須有它的使用方法，而執行緒啟動的主方法是需要覆寫Thread類中的run()方法才可以(相當于執行緒的主方法)，

package com.day12.demo;
class MyThread extends Thread{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	public void run(){
		for (int i = 0; i < 5; i++) {
			System.out.println(this.title + ",i = " + i);
		}
	}
}
public class ThreadDemo {
	@SuppressWarnings("unused")
	public static void main(String[] args) {
		MyThread thread1 = new MyThread("執行緒1");
		MyThread thread2 = new MyThread("執行緒2");
		MyThread thread3 = new MyThread("執行緒3");
		thread1.run();
		thread2.run();
		thread3.run();
	}
}

我們只是做了一個順序列印操作，而和多執行緒沒有關系，多執行緒的執行和行程是相似的，而是多個程式交替執行，而不是說各自執行各自的，正確啟動多執行緒的方式應該是呼叫Thread類中的start()方法，

啟動多執行緒只有一個方法：public void start(); 呼叫此方法會呼叫run()

正確啟動多執行緒

package com.day12.demo;
class MyThread extends Thread{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	public void run(){
		for (int i = 0; i < 5; i++) {
			System.out.println(this.title + ",i = " + i);
		}
	}
}
public class ThreadDemo {
	@SuppressWarnings("unused")
	public static void main(String[] args) {
		MyThread thread1 = new MyThread("執行緒1");
		MyThread thread2 = new MyThread("執行緒2");
		MyThread thread3 = new MyThread("執行緒3");
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

此時再次執行代碼發現所有所有的執行緒物件變為交替執行，所以得出結論：要想啟動執行緒必須依靠Thread類的start()方法執行，執行緒啟動之后會默認呼叫了run()方法，

問題：為什么執行緒啟動的時候必須呼叫start()而不是直接呼叫run()？

如果想要了解必須打開Java源代碼進行瀏覽（在JDK按照目錄下）

public synchronized void start() {
    /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
    if (threadStatus != 0)
        //這個例外的產生只有在你重復啟動執行緒的時候才會發生
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        //只宣告未實作的方法，同時使用native關鍵字定義，native呼叫本機的原生系統函式
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
        }
    }
}

多執行緒的實作一定需要作業系統的支持，那么例外的start0()方法實際上就和抽象方法很類似沒有方法體，而這個方法體交給JVM去實作，即：在windows下的JVM可能使用A方法實作了start0()，而在Linux下的JVM可能使用了B方法實作了start0()，凡是在呼叫的時候并不會去關心集體是何方式實作了start0()方法，只會關心最終的操作結果，交給JVM去匹配了不同的作業系統，

? 所以多執行緒操作之中，使用start()方法啟動多執行緒的操作是需要進行作業系統函式呼叫的，

1.4 Runnable介面實作多執行緒

Thread類的核心功能就是進行執行緒的啟動，但是如果一個類直接繼承Threa類就會造成單繼承的局限，在Java中又提供了有另外一種實作Runable介面，

public interface Runnable{
	public void run();
}

分享：如何區分新老介面？

? 在JDK之中個，由于其發展的時間較長，那么會出現一些新的介面和老的介面，這兩者有一個最大的明顯特征：所有最早提供的介面方法里面都不加上public，所有的新介面里面都有public，

通過Runnable介面實作多執行緒

package com.day12.demo;
class MyThread implements Runnable{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	public void run(){
		for (int i = 0; i < 5; i++) {
			System.out.println(this.title + ",i = " + i);
		}
	}
}

這個時候和之前的繼承Thread類區別不大，但是唯一的好處就是避免了單繼承局限，不過現在問題也就來了，剛剛解釋過，如果要想啟動多執行緒依靠Thread類的start()方法完成，之前繼承Thread()類的時候可以將此方法直接繼承過來使用，但現在實作的是Runnable介面，沒有這個方法可以繼承了，為了解決這個問題，還是需要依靠Thread類完成，在Thread類中定義一個構造方法：public Thread(Runnable target)，接收Runnable介面物件，

利用Thread類啟動

public class ThreadDemo {
	@SuppressWarnings("unused")
	public static void main(String[] args) {
		MyThread thread1 = new MyThread("執行緒1");
		MyThread thread2 = new MyThread("執行緒2");
		MyThread thread3 = new MyThread("執行緒3");
		new Thread(thread1).start();
		new Thread(thread2).start();
		new Thread(thread3).start();
	}
}

這個時候就實作了多執行緒的啟動，而且沒有了單繼承局限，

1.5 Thread類和Runnable介面實作多執行緒的區別

現在Thread類Runnable介面都可以作為同一功能的方式來實作多執行緒，那么這兩者如果從Java的十年開發而言，肯定使用Ruanable介面，因為可以有效的避免單繼承的局限，那么除了這些之外，這兩種方式是否還有其他聯系呢？

為了解釋這兩種方式的聯系，下面可以打開Thread類的定義：

Public class Thread Object implements Runnable

發現Thread類也是Runnable介面的子類，而如果真的是這樣，那么之前程式的結構就變為了一下形式，所以說多執行緒非常類似于代理模式，

這個時候表現出來的代碼模式非常類似于代理設計模式，但是它不是嚴格意義上的代理設計模式，因為從嚴格意義上來講代理設計模式之中，代理主體所能夠使用的方法依然是介面中定義的run()方法，而此處代理主題呼叫的是start()方法，所以只能夠說形式上類似于代理設計模式，但本質上還是有差別的，

但是除了以上的聯系之外，對于Runnable和Thread類還有一個不太好區分的區別：使用Runnable介面可以更加方便的表示出資料共享的概念，

買票程式

package com.day12.demo;
class MyTicket extends Thread{
	private int ticket = 10;
	public void run(){
		for (int i = 0; i < 20; i++) {
			if(ticket > 0)
			System.out.println("買票 =" + this.ticket--);
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		new MyTicket().start();
		new MyTicket().start();
		new MyTicket().start();
	}
}

運行后發現，資料沒有共享，

package com.day12.demo;
class MyTicket extends Thread{
	private int ticket = 10;
	public void run(){
		for (int i = 0; i < 20; i++) {
			if(ticket > 0)
			System.out.println("買票 =" + this.ticket--);
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		
	}
}

經過改進之后，發現資料進行共享，但是對于邏輯是解釋是不好理解的，MyTicket類繼承了Thread類，自己擁有了start()方法但是不執行自己的start()方法，而是通過匿名方法共用MyTicket()實體化物件mt呼叫匿名方法的start()方法，

再次經過改進之后

package com.day12.demo;
class MyTicket implements Runnable{
	private int ticket = 10;
	public void run(){
		for (int i = 0; i < 20; i++) {
			if(ticket > 0)
			System.out.println("買票 =" + this.ticket--);
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		
	}
}

通過MyTicket類實作Runnable介面來進行改進，原因是因為Runnable介面里面只有一個自己的run()方法，而此處的start()的方法，是通過匿名類進行呼叫start()方法來實作執行緒的啟動，

面試題：請解釋多執行緒的兩種實作方式區別？分別撰寫程式驗證兩種實作，

多執行緒的兩種實作方式都需要一個執行緒的主類，而這個類可以實作Runnable介面或繼承Thread，不管使用何種方式都必須在子類之中覆寫run()方法，此方法為執行緒的主方法；

Thread類是Runnable介面的子類，而且使用Runnable介面可以避免單繼承局限，以及更加方便的實作資料共享的概念，

Runnable 介面：

class MyThread implements Runnable{
	private int ticket=5;
	public void run(){
		for(int x=0;x<50;x++)
			if(this.ticket>0){
				System.out.println(this.ticket--);
			}
	}
}

MyThread mt = new MyThread();
new Thread(mt).start();

Thread 類：

class MyThread extends Thread{
	private int ticket=5;
	public void run(){
		for(int x=0;x<50;x++)
			if(this.ticket>0){
				System.out.println(this.ticket--);
			}
	}
}

MyThread mt = new MyThread();
mt.start();

1.6 執行緒的操作狀態

當我們多執行緒呼叫start方法之后不會立刻執行，而是進入就緒狀態，等待進行調度后執行，需要將資源分配給你運行后，才可以執行多執行緒的代碼run()中的代碼當執行一段時間之后，你需要讓出資源，讓其他執行緒來執行，這個時候run()方法可能還沒有執行完成，只執行了一半，那么我么我們就需要讓資源，隨后重新進入就緒狀態，重新等待分配新資源繼續執行，當執行緒執行完畢后才會進入終止狀態，總結就一句話：執行緒執行需要分配資源，資源不能獨占，執行一會讓出資源給其他程式執行，

1.7 Callable實作多執行緒

jdk增加新的工具類java.util.concurrent

@FunctionalInterface
public interface Callable<V>

Runnable中的run()方法雖然也是執行緒的主方法，但是其沒有回傳值，因為它的設計遵循了我們主方法的設計原則：執行緒開始就別回頭，但是在很多時候需要一些回傳值，例如：當某些執行緒執行完成后可能帶來一些回傳結果，這種情況下我們就只能通過Callabale來實作多執行緒，

通過分析源代碼可以找到一些關系

Callable定義執行緒主方法啟動并取得多執行緒執行的總結果

package com.day12.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyTicket1 implements Callable<String>{	
	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		for (int i = 0; i < 20; i++) {
			System.out.println("買票 ,x = " + i);
		}
		return "票賣完了，下次吧";
	}
}
public class CallableDemo {
	@SuppressWarnings({ "unused", "rawtypes", "unchecked" })
	public static void main(String[] args) throws Exception {
		FutureTask<String> task = new FutureTask<>(new MyTicket1());
		new Thread(task).start();
		System.out.println(task.get());
	}
}

這種形式主要就是回傳我們的操作結果，

1.8 執行緒命名和取得

執行緒本身是屬于不可見的運行狀態的，即：每次操作的時候是無法預料的，所以如果要想在程式之中操作執行緒，唯一依靠的就是執行緒的名稱，而要想取得和設定執行緒的名稱可以使用以下的方法：

方法名稱	型別	描述
public Thread(Runnable target,String name)；	構造	宣告引數
public final void setName(String name)；	普通	設定執行緒名稱
public final String getName()	普通	取得執行緒名稱

但是由于執行緒的狀態不確定，所以每次可以操作的執行緒都是正在執行run()方法的執行緒，那么取得當前執行緒物件的方法：public static Thread currentThread()，

執行緒名稱的取得

package com.day12.demo;

class MyThread implements Runnable{
	public void run(){
		System.out.println(Thread.currentThread().getName());
			}
}
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread mt = new MyThread();
		new Thread(mt).start();//Thread-0
		new Thread(mt).start();//Thread-1
		new Thread(mt).start();//Thread-2
		new Thread(mt,"A").start();//A
		new Thread(mt,"B").start();//B
		new Thread(mt,"C").start();//C
	}
}

如果說現在為執行緒設定名字的話，那么會使用用戶定義的名字，而如果沒有設定執行緒名稱，會自動分配一個名稱這一點操作和之前講解的static命名類似，

package com.day12.demo;
class MyThread2 implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName());
	}
	
}
public class RenameThreadDemo {
	public static void main(String[] args) {
		MyThread2 mt = new MyThread2();
		mt.run();//直接通過物件呼叫方法
		new Thread(mt).start();
	}
}

觀察以上程式我們發現，執行緒的啟動都是通過主執行緒創建并啟動的，主方法就是一個執行緒，

行程在哪里？

實際上每當使用了java命令去解釋程式的時候，都表示啟動了一個新的JVM行程，而主方法只是這個行程上的一個執行緒而已，

1.9 執行緒的休眠

執行緒的休眠指的是讓程式休息一會等時間到了在進行執行，方法：public static void sleep(long millis) throws InterruptedException，設定的休眠單位是毫秒，

package com.day12.demo;
class MyThread implements Runnable{
	public void run(){
		for(int x=0;x<100;x++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"x="+x);
		}
	}
}
public class Test {
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		MyThread mt = new MyThread();
		new Thread(mt,"執行緒A").start();
		new Thread(mt,"執行緒B").start();
	}
}

1.10 執行緒的優先級

從理論上講，執行緒的優先級越高，越有可能先執行，如果要想操作執行緒的優先級有如下兩個方法：

設定執行緒優先級：public final void setPriority(int newPriority);
取得執行緒優先級：public final int getPriority();

發現設定取得優先級的時候都是利用一個int型資料的操作，而這個int型資料有三種取值：

? **最高優先級：**public static final int MAX_PRIORITY，10；

? **中等優先級：**public static final int NORM_PRIORITY，5；

? **最低優先級：**public static final int MIN_PRIORITY，1；

設定優先級

package com.day12.demo;
class MyThread3 implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "i = "+ i);
		}
	}
	
}
public class PriorityDemo {
	public static void main(String[] args) {
		MyThread3 mt = new MyThread3();
		Thread thread1 = new Thread(mt,"執行緒A");
		Thread thread2 = new Thread(mt,"執行緒B");
		Thread thread3 = new Thread(mt,"執行緒C");
		thread1.setPriority(Thread.MIN_PRIORITY);
		thread2.setPriority(Thread.MAX_PRIORITY);
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

主方法只是一個中等優先級，

1.11 執行緒的同步與死鎖

所謂的同步問題是指多個執行緒操作統一次元所帶來的資訊安全性問題，

下面模擬一個簡單的賣票程式，要求有3個執行緒，賣10張票，

package com.day12.demo;
class MyTicket implements Runnable{
	private int ticket = 10;
	public void run(){
		for (int i = 0; i < 20; i++) {
			if(ticket > 0){
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "買票 =" + this.ticket--);
			}
			
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		new Thread(mt,"票販子A").start();
		new Thread(mt,"票販子B").start();
		new Thread(mt,"票販子C").start();
		
	}
}

運行上面程式發現，票數為0或者為負數，這種操作我們稱為不同步操作，

不同步的唯一好處就是處理速度快（多個執行緒并發執行），而去銀行是一個業務員對應一個客戶，這個速度必然很慢，資料的不同步對于訪問是不安全的操作，

同步是指所有的執行緒不是一起進入方法中執行，而是一個一個進來執行，

如果要寫實作這把鎖的功能，那么可以使用synchronized關鍵字進行處理，有兩種處理模式：同步代碼塊、同步方法，

同步代碼塊

如果要使用這種情況必須設定一個要鎖定當前物件

package com.day12.demo;
class MyTicket implements Runnable{
	private int ticket = 2000;
	public void run(){
		for (int i = 0; i < 1000; i++) {
			//在同一時刻，只允許一個執行緒進入并且操作，其他執行緒需要等待
			synchronized(this){//執行緒的邏輯鎖
				if(ticket > 0){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "買票 =" + this.ticket--);
				}
			}
			
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		Thread thread1 = new Thread(mt,"票販子A");
		thread1.setPriority(Thread.MIN_PRIORITY);
		thread1.start();
		new Thread(mt,"票販子B").start();
		new Thread(mt,"票販子C").start();
		
	}
}

同步方法

package com.day12.demo;
class MyTicket implements Runnable{
	private int ticket = 2000;
	public void run(){
		for (int i = 0; i < 1000; i++) {
			//在同一時刻，只允許一個執行緒進入并且操作，其他執行緒需要等待
			synchronized(this){//執行緒的邏輯鎖
				this.sale();
			}
		}
	}
	public synchronized void sale(){
		if(ticket > 0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
			System.out.println(Thread.currentThread().getName() + "買票 =" + this.ticket--);
		}
	}
}
public class TicketDemo {
	public static void main(String[] args) {
		MyTicket mt = new MyTicket();
		Thread thread1 = new Thread(mt,"票販子A");
		thread1.setPriority(Thread.MIN_PRIORITY);
		thread1.start();
		new Thread(mt,"票販子B").start();
		new Thread(mt,"票販子C").start();
		
	}
}

同步雖然可以保證資料的完整性（執行緒安全操作），但是其執行的速度很慢，

1.12 死鎖

一個執行緒執行完畢后才可以繼續執行，但是如果現在相關的幾個執行緒，彼此幾個執行緒都在等待（同步），那么就會造成死鎖，

模擬死鎖程式

package com.day12.demo;
class JieFei{
	public synchronized void say(Person Person){
		System.out.println("給錢放人");
		Person.get();
	}
	public synchronized void get(){
		System.out.println("得到錢");
	}
}
class Person{
	public synchronized void say(JieFei jiefei){
		System.out.println("放人就給錢");
		jiefei.get();
	}
	public synchronized void get(){
		System.out.println("得到人");
	}
}
public class DeadLock implements Runnable {
	JieFei jie = new JieFei();
	Person person = new Person();
	public static void main(String[] args) {
		// TODO 自動生成的方法存根
		new DeadLock(); 
	}
	public DeadLock(){
		new Thread(this).start();
		jie.say(person);
	}
	@Override
	public void run() {
		// TODO 自動生成的方法存根
		person.say(jie);
	}
}

死鎖實在日后多執行緒程式開發之中經常會遇見問題，而以上的代碼并沒有任何實際意義，大概可以理解死鎖的操作形式就可以了，不用去研究程式，記住一句話：資料要想完整操作必須使用同步，但是過多的同步會造成死鎖，

面試題：請問多執行緒操作統一資源的時候要考慮到那些，會帶來的問題？

多執行緒訪問統一資源的時候一定要考慮同步的問題，但是過多的同步會帶來死鎖，

綜合案例

生產者和消費者是一道最為經典的供求案例：provider、consumer，不管是之后的分布式開發還是其他開發都被大量采用，

生產者只是負責生產資料，而生產者每生產一個完整的資料，消費者就把這個資料拿走，假設生產如下資料 title = 生產，note = 出庫；title=拿貨， note = 消費

package com.day12.demo;

class Message{
	private String title;
	private String note;
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getNote() {
		return note;
	}
	public void setNote(String note) {
		this.note = note;
	}
	
}
class Productor implements Runnable{
	Message msg = null;
	public Productor(Message msg){
		this.msg=msg;
	}

	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for(int x = 0;x<50;x++){
			if(x%2==0){
				try {
					msg.setTitle("生產");
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO 自動生成的 catch 塊
					e.printStackTrace();
				}
				msg.setNote("出庫");
			}else{
				msg.setNote("拿貨");
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO 自動生成的 catch 塊
					e.printStackTrace();
				}
				msg.setNote("消費");
			}
		}
	}
}
class Consumer implements Runnable{
	Message msg = null;
	public Consumer(Message msg){
		this.msg=msg;
	}
	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for(int x= 0;x<50;x++){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO 自動生成的 catch 塊
				e.printStackTrace();
			}
			System.out.println(this.msg.getTitle()+"--->"+this.msg.getNote());
		}
	}
}	
public class PCDemo {
	public static void main(String args[]){
		// TODO 自動生成的方法存根
		Message msg = new Message();
		Productor pro = new Productor(msg);
		Consumer con = new Consumer(msg);
		new Thread(pro).start();
		new Thread(con).start();
	}
}

但是例外的代碼模型出現了如下的兩個嚴重的問題：

資料錯位了
出現了重復取出和重復設定的問題

1.解決資料錯位問題：依靠同步解決

package com.day12.demo;

class Message {
	private String title;
	private String note;

	public synchronized void set(String title, String note) {
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO 自動生成的 catch 塊
			e.printStackTrace();
		}
		this.title = title;

		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO 自動生成的 catch 塊
			e.printStackTrace();
		}
		this.note = note;
	}

	public synchronized void get() {
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO 自動生成的 catch 塊
			e.printStackTrace();
		}
		System.out.println(this.title + "--->" + this.note);
	}
}

class Productor implements Runnable {
	Message msg;

	public Productor(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for (int x = 0; x < 50; x++) {
			if (x % 2 == 0) {
				msg.set("生產", "出庫");
			} else {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO 自動生成的 catch 塊
					e.printStackTrace();
				}
				msg.set("拿貨", "消費");
			}
		}
	}
}

class Consumer implements Runnable {
	Message msg = null;

	public Consumer(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for (int x = 0; x < 50; x++) {
			msg.get();
		}
	}
}

public class PCDemo {
	public static void main(String args[]) {
		// TODO 自動生成的方法存根
		Message msg = new Message();
		Productor pro = new Productor(msg);
		Consumer con = new Consumer(msg);
		new Thread(pro).start();
		new Thread(con).start();
	}
}

雖然解決了錯位的問題，但是重復設定重復取出更加嚴重了，

2.解決資料的重復設定和重復取出

要想解決重復的問題需要等待及喚醒機制，而這一機制的實作只能依靠Object類完成，在Object類之中定義了以下的三個方法完成執行緒操作：

方法名稱	型別	描述
public final void wait() throws InterruptedException	普通	等待、死等
public final void notify()	普通	喚醒第一個等待執行緒
public final void notifyAll()	普通	喚醒全部等待執行緒

通過等待與喚醒機制來解決資料的重復操作問題

package com.day12.demo;

class Message {
	private String title;
	private String note;
	//flag = true  允許生產但是不允許消費者取走
	//flag = false 生產完畢 允許消費者取走，但是不能夠生產
	private boolean flag = false;
	public synchronized void set(String title, String note) {
		if(flag == true){//生產完畢 允許消費者取走，但是不能夠生產
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.title = title;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO 自動生成的 catch 塊
			e.printStackTrace();
		}
		this.note = note;
		flag = true;
		super.notify();
	}

	public synchronized void get() {
		if(flag == false){ //允許生產但是不允許消費者取走
			try {
				super.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO 自動生成的 catch 塊
			e.printStackTrace();
		}
		System.out.println(this.title + "--->" + this.note);
		flag = false;
		super.notify();
	}
}

class Productor implements Runnable {
	Message msg;

	public Productor(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for (int x = 0; x < 50; x++) {
			if (x % 2 == 0) {
				msg.set("生產", "出庫");
			} else {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO 自動生成的 catch 塊
					e.printStackTrace();
				}
				msg.set("拿貨", "消費");
			}
		}
	}
}

class Consumer implements Runnable {
	Message msg = null;

	public Consumer(Message msg) {
		this.msg = msg;
	}

	@Override
	public void run() {
		// TODO 自動生成的方法存根
		for (int x = 0; x < 50; x++) {
			msg.get();
		}
	}
}

public class PCDemo {
	public static void main(String args[]) {
		// TODO 自動生成的方法存根
		Message msg = new Message();
		Productor pro = new Productor(msg);
		Consumer con = new Consumer(msg);
		new Thread(pro).start();
		new Thread(con).start();
	}
}

面試題：請解釋sleep()和wait()的區別？

sleep()是Thread類中定義的方法，到了一定的時間后該休眠的執行緒自動喚醒，自動喚醒，
wait()是Object類中定義的方法，如果要想喚醒，必須使用notify()、notifyAll()才能喚醒，手動喚醒，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/294700.html

標籤：java

上一篇：超級硬核！Android高級進階路線總結，已 Get 大廠 Offer，建議立馬收藏！

下一篇：高級JAVA開發必須掌握技能java8 新日期時間API（(一)JSR-310：ZoneId 時區和偏移量），2萬字詳解（全程干貨，建議收藏）

# Day12-Java基礎