Java多線程與優(yōu)先級詳細解讀
1、多線程
要使用多線程必須有一個前提，有一個線程的執(zhí)行主類。從多線程開始，Java正式進入到應用部分，而對于多線程的開發(fā)，從JavaEE上表現(xiàn)的并不是特別多，但是在Android開發(fā)之中使用較多，并且需要提醒的是，鄙視面試的過程之中，多線程所問道的問題是最多的。
1.1 多線程的基本概念
如果要想解釋多線程，那么首先應該從單線程開始講起，最早的DOS系統(tǒng)有一個最大的特征：一旦電腦出現(xiàn)了病毒，電腦會立刻死機，因為傳統(tǒng)DOS系統(tǒng)屬于單進程的處理方式，即：在同一個時間段上只能有一個程序執(zhí)行，后來到了windows時代，電腦即使（非致命）存在了病毒，那么也可以正常使用，只是滿了一些而已，因為windows屬于多進程的處理操作，但是這個時候的資源依然只有一塊，所以在同一時間段上會有多個程序共同執(zhí)行，而在一個時間點上只能有一個程序在執(zhí)行，多線程實在一個進程基礎之上的進一步劃分，因為進程的啟動所消耗的時間是非常長的，所以在進程之上的進一步劃分就變得非常重要，而且性能也會有所提高。
所有的線程一定要依附于進程才能夠存在，那么進程一旦消失了，線程也一定會消失，但反過來不一定，而Java是為數(shù)不多的支持多線程的開發(fā)語言之一。
1.2 多線程的實現(xiàn)
在Java之中，如果要想實現(xiàn)多線程的程序，就必須依靠一個線程的主體類（叫好比主類的概念一樣，表示的是一個線程的主類），但是這個線程的主體類在定義的時候也需要有一些特殊的要求，這個類可以繼承Thread類或?qū)崿F(xiàn)Runnable接口來完成定義。
1.3 繼承Thread類實現(xiàn)多線程
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();
}
}
我們只是做了一個順序打印操作，而和多線程沒有關系。多線程的執(zhí)行和進程是相似的，而是多個程序交替執(zhí)行，而不是說各自執(zhí)行各自的。正確啟動多線程的方式應該是調(diào)用Thread類中的start()方法。
啟動多線程只有一個方法：public void start(); 調(diào)用此方法會調(diào)用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();
}
}
此時再次執(zhí)行代碼發(fā)現(xiàn)所有所有的線程對象變?yōu)榻惶鎴?zhí)行。所以得出結(jié)論：要想啟動線程必須依靠Thread類的start()方法執(zhí)行，線程啟動之后會默認調(diào)用了run()方法。
問題：為什么線程啟動的時候必須調(diào)用start()而不是直接調(diào)用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)
//這個異常的產(chǎn)生只有在你重復啟動線程的時候才會發(fā)生
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 {
//只聲明未實現(xiàn)的方法，同時使用native關鍵字定義，native調(diào)用本機的原生系統(tǒng)函數(shù)
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 */
}
}
}
多線程的實現(xiàn)一定需要操作系統(tǒng)的支持，那么異常的start0()方法實際上就和抽象方法很類似沒有方法體，而這個方法體交給JVM去實現(xiàn)，即：在windows下的JVM可能使用A方法實現(xiàn)了start0()，而在Linux下的JVM可能使用了B方法實現(xiàn)了start0()，凡是在調(diào)用的時候并不會去關心集體是何方式實現(xiàn)了start0()方法，只會關心最終的操作結(jié)果，交給JVM去匹配了不同的操作系統(tǒng)。
所以多線程操作之中，使用start()方法啟動多線程的操作是需要進行操作系統(tǒng)函數(shù)調(diào)用的。
1.4 Runnable接口實現(xiàn)多線程
Thread類的核心功能就是進行線程的啟動，但是如果一個類直接繼承Threa類就會造成單繼承的局限，在Java中又提供了有另外一種實現(xiàn)Runable接口。
public interface Runnable{
public void run();
}
分享：如何區(qū)分新老接口？
在JDK之中個，由于其發(fā)展的時間較長，那么會出現(xiàn)一些新的接口和老的接口，這兩者有一個最大的明顯特征：所有最早提供的接口方法里面都不加上public，所有的新接口里面都有public。
通過Runnable接口實現(xiàn)多線程
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類區(qū)別不大，但是唯一的好處就是避免了單繼承局限，不過現(xiàn)在問題也就來了，剛剛解釋過，如果要想啟動多線程依靠Thread類的start()方法完成，之前繼承Thread()類的時候可以將此方法直接繼承過來使用，但現(xiàn)在實現(xiàn)的是Runnable接口，沒有這個方法可以繼承了，為了解決這個問題，還是需要依靠Thread類完成，在Thread類中定義一個構(gòu)造方法：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();
}
}
這個時候就實現(xiàn)了多線程的啟動，而且沒有了單繼承局限。
1.5 Thread類和Runnable接口實現(xiàn)多線程的區(qū)別
現(xiàn)在Thread類Runnable接口都可以作為同一功能的方式來實現(xiàn)多線程，那么這兩者如果從Java的十年開發(fā)而言，肯定使用Ruanable接口，因為可以有效的避免單繼承的局限，那么除了這些之外，這兩種方式是否還有其他聯(lián)系呢？
為了解釋這兩種方式的聯(lián)系，下面可以打開Thread類的定義：
Public class Thread Object implements Runnable
發(fā)現(xiàn)Thread類也是Runnable接口的子類，而如果真的是這樣，那么之前程序的結(jié)構(gòu)就變?yōu)榱艘幌滦问健Ｋ哉f多線程非常類似于代理模式。
這個時候表現(xiàn)出來的代碼模式非常類似于代理設計模式，但是它不是嚴格意義上的代理設計模式，因為從嚴格意義上來講代理設計模式之中，代理主體所能夠使用的方法依然是接口中定義的run()方法，而此處代理主題調(diào)用的是start()方法，所以只能夠說形式上類似于代理設計模式，但本質(zhì)上還是有差別的。
但是除了以上的聯(lián)系之外，對于Runnable和Thread類還有一個不太好區(qū)分的區(qū)別：使用Runnable接口可以更加方便的表示出數(shù)據(jù)共享的概念。
買票程序
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();
}
}
運行后發(fā)現(xiàn)，數(shù)據(jù)沒有共享。
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();
}
}
經(jīng)過改進之后，發(fā)現(xiàn)數(shù)據(jù)進行共享，但是對于邏輯是解釋是不好理解的，MyTicket類繼承了Thread類，自己擁有了start()方法但是不執(zhí)行自己的start()方法，而是通過匿名方法共用MyTicket()實例化對象mt調(diào)用匿名方法的start()方法。
再次經(jīng)過改進之后
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類實現(xiàn)Runnable接口來進行改進，原因是因為Runnable接口里面只有一個自己的run()方法，而此處的start()的方法，是通過匿名類進行調(diào)用start()方法來實現(xiàn)線程的啟動。
面試題：請解釋多線程的兩種實現(xiàn)方式區(qū)別？分別編寫程序驗證兩種實現(xiàn)。
多線程的兩種實現(xiàn)方式都需要一個線程的主類，而這個類可以實現(xiàn)Runnable接口或繼承Thread，不管使用何種方式都必須在子類之中覆寫run()方法，此方法為線程的主方法；
Thread類是Runnable接口的子類，而且使用Runnable接口可以避免單繼承局限，以及更加方便的實現(xiàn)數(shù)據(jù)共享的概念。
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 線程的操作狀態(tài)
當我們多線程調(diào)用start方法之后不會立刻執(zhí)行，而是進入就緒狀態(tài)，等待進行調(diào)度后執(zhí)行，需要將資源分配給你運行后，才可以執(zhí)行多線程的代碼run()中的代碼當執(zhí)行一段時間之后，你需要讓出資源，讓其他線程來執(zhí)行，這個時候run()方法可能還沒有執(zhí)行完成，只執(zhí)行了一半，那么我么我們就需要讓資源，隨后重新進入就緒狀態(tài)，重新等待分配新資源繼續(xù)執(zhí)行。當線程執(zhí)行完畢后才會進入終止狀態(tài)?？偨Y(jié)就一句話：線程執(zhí)行需要分配資源，資源不能獨占，執(zhí)行一會讓出資源給其他程序執(zhí)行。
1.7 Callable實現(xiàn)多線程
jdk增加新的工具類java.util.concurrent
@FunctionalInterface public interface Callable<V>
Runnable中的run()方法雖然也是線程的主方法，但是其沒有返回值，因為它的設計遵循了我們主方法的設計原則：線程開始就別回頭。但是在很多時候需要一些返回值，例如：當某些線程執(zhí)行完成后可能帶來一些返回結(jié)果，這種情況下我們就只能通過Callabale來實現(xiàn)多線程。
通過分析源代碼可以找到一些關系
Callable定義線程主方法啟動并取得多線程執(zhí)行的總結(jié)果
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());
}
}
這種形式主要就是返回我們的操作結(jié)果。
1.8 線程命名和取得
線程本身是屬于不可見的運行狀態(tài)的，即：每次操作的時候是無法預料的，所以如果要想在程序之中操作線程，唯一依靠的就是線程的名稱，而要想取得和設置線程的名稱可以使用以下的方法：
| 方法名稱 | 類型 | 描述 |
| public Thread(Runnable target,String name)； | 構(gòu)造 | 聲明參數(shù) |
| public final void setName(String name)； | 普通 | 設置線程名稱 |
| public final String getName() | 普通 | 取得線程名稱 |
但是由于線程的狀態(tài)不確定，所以每次可以操作的線程都是正在執(zhí)行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
}
}
如果說現(xiàn)在為線程設置名字的話，那么會使用用戶定義的名字，而如果沒有設置線程名稱，會自動分配一個名稱這一點操作和之前講解的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();//直接通過對象調(diào)用方法
new Thread(mt).start();
}
}
觀察以上程序我們發(fā)現(xiàn)，線程的啟動都是通過主線程創(chuàng)建并啟動的，主方法就是一個線程。
進程在哪里？
實際上每當使用了java命令去解釋程序的時候，都表示啟動了一個新的JVM進程。而主方法只是這個進程上的一個線程而已。
1.9 線程的休眠
線程的休眠指的是讓程序休息一會等時間到了在進行執(zhí)行。方法：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 線程的優(yōu)先級
從理論上講，線程的優(yōu)先級越高，越有可能先執(zhí)行。如果要想操作線程的優(yōu)先級有如下兩個方法：
設置線程優(yōu)先級：public final void setPriority(int newPriority);
取得線程優(yōu)先級：public final int getPriority();
發(fā)現(xiàn)設置取得優(yōu)先級的時候都是利用一個int型數(shù)據(jù)的操作，而這個int型數(shù)據(jù)有三種取值：
**最高優(yōu)先級：**public static final int MAX_PRIORITY，10；
**中等優(yōu)先級：**public static final int NORM_PRIORITY，5；
**最低優(yōu)先級：**public static final int MIN_PRIORITY，1；
設置優(yōu)先級
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();
}
}
主方法只是一個中等優(yōu)先級。
1.11 線程的同步與死鎖
所謂的同步問題是指多個線程操作統(tǒng)一次元所帶來的信息安全性問題，
下面模擬一個簡單的賣票程序，要求有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();
}
}
運行上面程序發(fā)現(xiàn)，票數(shù)為0或者為負數(shù)，這種操作我們稱為不同步操作。
不同步的唯一好處就是處理速度快（多個線程并發(fā)執(zhí)行），而去銀行是一個業(yè)務員對應一個客戶，這個速度必然很慢。數(shù)據(jù)的不同步對于訪問是不安全的操作。
同步是指所有的線程不是一起進入方法中執(zhí)行，而是一個一個進來執(zhí)行。
如果要寫實現(xiàn)這把鎖的功能，那么可以使用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();
}
}
同步雖然可以保證數(shù)據(jù)的完整性（線程安全操作），但是其執(zhí)行的速度很慢。
1.12 死鎖
一個線程執(zhí)行完畢后才可以繼續(xù)執(zhí)行，但是如果現(xiàn)在相關的幾個線程，彼此幾個線程都在等待（同步），那么就會造成死鎖。
模擬死鎖程序
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);
}
}
死鎖實在日后多線程程序開發(fā)之中經(jīng)常會遇見問題，而以上的代碼并沒有任何實際意義，大概可以理解死鎖的操作形式就可以了，不用去研究程序。記住一句話：數(shù)據(jù)要想完整操作必須使用同步，但是過多的同步會造成死鎖。
面試題：請問多線程操作統(tǒng)一資源的時候要考慮到那些，會帶來的問題？
多線程訪問統(tǒng)一資源的時候一定要考慮同步的問題，但是過多的同步會帶來死鎖。
綜合案例
生產(chǎn)者和消費者是一道最為經(jīng)典的供求案例：provider、consumer。不管是之后的分布式開發(fā)還是其他開發(fā)都被大量采用。
生產(chǎn)者只是負責生產(chǎn)數(shù)據(jù)，而生產(chǎn)者每生產(chǎn)一個完整的數(shù)據(jù)，消費者就把這個數(shù)據(jù)拿走。假設生產(chǎn)如下數(shù)據(jù) title = 生產(chǎn)，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("生產(chǎn)");
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();
}
}
但是異常的代碼模型出現(xiàn)了如下的兩個嚴重的問題：
數(shù)據(jù)錯位了出現(xiàn)了重復取出和重復設置的問題
1.解決數(shù)據(jù)錯位問題：依靠同步解決
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("生產(chǎn)", "出庫");
} 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.解決數(shù)據(jù)的重復設置和重復取出
要想解決重復的問題需要等待及喚醒機制，而這一機制的實現(xiàn)只能依靠Object類完成，在Object類之中定義了以下的三個方法完成線程操作：
| 方法名稱 | 類型 | 描述 |
| public final void wait() throws InterruptedException | 普通 | 等待、死等 |
| public final void notify() | 普通 | 喚醒第一個等待線程 |
| public final void notifyAll() | 普通 | 喚醒全部等待線程 |
通過等待與喚醒機制來解決數(shù)據(jù)的重復操作問題
package com.day12.demo;
class Message {
private String title;
private String note;
//flag = true 允許生產(chǎn)但是不允許消費者取走
//flag = false 生產(chǎn)完畢 允許消費者取走，但是不能夠生產(chǎn)
private boolean flag = false;
public synchronized void set(String title, String note) {
if(flag == true){//生產(chǎn)完畢 允許消費者取走，但是不能夠生產(chǎn)
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){ //允許生產(chǎn)但是不允許消費者取走
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("生產(chǎn)", "出庫");
} 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()的區(qū)別？
- sleep()是Thread類中定義的方法，到了一定的時間后該休眠的線程自動喚醒，自動喚醒。
- wait()是Object類中定義的方法，如果要想喚醒，必須使用notify()、notifyAll()才能喚醒，手動喚醒。
到此這篇關于Day12基礎不牢地動山搖-Java基礎的文章就介紹到這了,更多相關Java基礎內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了java Scanner輸入數(shù)字、字符串過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-10-10
這篇文章主要介紹了Java實現(xiàn)雙向鏈表(兩個版本)的相關資料,需要的朋友可以參考下2016-02-02
因為Spring Boot框架開發(fā)的便利性，所以實現(xiàn)Spring Boot與數(shù)據(jù)訪問層框架（例如MyBatis）的整合非常簡單，主要是引入對應的依賴啟動器，并進行數(shù)據(jù)庫相關參數(shù)設置即可2022-06-06
JSP頁面?zhèn)鲄⒊霈F(xiàn)中文亂碼的解決方案
這篇文章主要介紹了JSP頁面?zhèn)鲄⒊霈F(xiàn)中文亂碼的解決方案,非常實用,需要的朋友可以參考下2014-08-08
SpringBoot 下集成緩存工具類 CacheManager
這篇文章主要介紹了Springboot下集成緩存工具類CacheManager，想進一步了解相關知識的同學，可以詳細閱讀本文2023-03-03
Java數(shù)據(jù)結(jié)構(gòu)之鏈表、棧、隊列、樹的實現(xiàn)方法示例
這篇文章主要介紹了Java數(shù)據(jù)結(jié)構(gòu)之鏈表、棧、隊列、樹的實現(xiàn)方法,結(jié)合實例形式分析了Java數(shù)據(jù)結(jié)構(gòu)中鏈表、棧、隊列、樹的功能、定義及使用方法,需要的朋友可以參考下2019-03-03
這篇文章主要介紹了使用feign客戶端傳參接收不到的問題及解決，具有很好的參考價值，希望對大家有所幫助。2022-03-03
這篇文章主要介紹了Netty分布式監(jiān)聽讀事件方法的代碼跟蹤解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-03-03
這篇文章主要介紹了詳解Java如何獲取文件編碼格式，具有一定的參考價值，感興趣的小伙伴們可以參考一下。2017-01-01
詳解Java中多線程異常捕獲Runnable的實現(xiàn)
這篇文章主要介紹了詳解Java中多線程異常捕獲Runnable的實現(xiàn)的相關資料,希望通過本文能幫助到大家，讓大家理解掌握這樣的知識，需要的朋友可以參考下2017-10-10