快捷導(dǎo)航

新手場景Java線程相關(guān)問題及解決方案

更新時間：2020年07月01日 09:39:44 作者：等你的夏天

這篇文章主要介紹了新手場景Java線程相關(guān)問題及解決方案,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下

一、創(chuàng)建線程方式

a. 繼承線程類（ new Thread），重寫run方法；

public class MyThread extends Thread{//繼承Thread類
　　public void run(){
　　//重寫run方法
　　}
}
public class Main {
public static void main(String[] args){
　　　　new MyThread().start();//創(chuàng)建并啟動線程
　　}
}

b. 實(shí)現(xiàn)runnable接口，將runnable對象傳入Thread類；

public class MyThread2 implements Runnable {//實(shí)現(xiàn)Runnable接口
　　public void run(){
　　//重寫run方法
　　}
}
public class Main {
　　public static void main(String[] args){
　　　　//創(chuàng)建并啟動線程
　　　　MyThread2 myThread=new MyThread2();
　　　　Thread thread=new Thread(myThread);
　　　　thread().start();
　　　　//或者  new Thread(new MyThread2()).start();
　　}
}

c. 使用線程池的方式，提交runnable或callable任務(wù)；

public class Main {
　　public static void main(String[] args){
　　　MyThread3 th=new MyThread3();
　　　//使用Lambda表達(dá)式創(chuàng)建Callable對象
　　 //使用FutureTask類來包裝Callable對象
　　　FutureTask<Integer> future=new FutureTask<Integer>(
　　　　(Callable<Integer>)()->{
　　　　　　return 5;
　　　　}
　　 );
　　　new Thread(task,"有返回值的線程").start();//實(shí)質(zhì)上還是以Callable對象來創(chuàng)建并啟動線程
　　 try{
　　　　System.out.println("子線程的返回值："+future.get());//get()方法會阻塞，直到子線程執(zhí)行結(jié)束才返回
　　 }catch(Exception e){
　　　　ex.printStackTrace();
　　　}
　　}
}

d. 推薦使用第三種方式。高效，資源可控；

二、什么是線程同步？線程同步什么時候用？

1）什么是線程同步；

即當(dāng)有一個線程在對內(nèi)存進(jìn)行操作時，其他線程都不可以對這個內(nèi)存地址進(jìn)行操作，直到該線程完成操作，其他線程才能對該內(nèi)存地址進(jìn)行操作，而其他線程又處于等待狀態(tài)；

2）線程同步在什么時候用（賣火車票，飛機(jī)票，取錢）；

簡單的說，同步就是防止多個線程訪問同一個對象，造成數(shù)據(jù)不安全；線程的同步意味安全，譬如你去取錢，你的執(zhí)行語句和我用的要是相同對象，你要在卡上扣除的錢數(shù)和銀行卡里面要有這么多錢才能扣除；

三、什么是線程安全；

1）所謂線程安全，是多個線程并發(fā)執(zhí)行的情況下結(jié)果總是跟單線程運(yùn)行的結(jié)果一致，邏輯上不會出現(xiàn)錯誤；

2）什么情況下會出現(xiàn)線程安全問題？

多個線程同時操作同一份數(shù)據(jù)，常常會導(dǎo)致線程安全問題。比如：全局的變量，靜態(tài)變量，同一條數(shù)據(jù)的數(shù)據(jù)庫操作等；

局部變量，通常不會存在線程安全問題。

3）常見的解決線程安全的方式：

1）避免使用全局的變量，將全局的變量定義為局部變量。

2）加同步鎖，使得線程同步。

a. Synchronized 同步關(guān)鍵字，可以加在方法和代碼塊上面；

/**
   * synchronized添加到方法上面，使方法變成同步方法
   * 如果是靜態(tài)方法，鎖住的是class
   * 如果是普通方法，鎖住的this,當(dāng)前對象 synchronized(this)
   * 多個線程鎖住的對象是同一個對象才能夠同步，每個類都有當(dāng)前對象
   */

  public static synchronized void salTicket(){
    if (ticketNum > 0) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + "買到第" + ticketNum-- + "張票");
      System.out.println(Thread.currentThread().getName() + "買票完成");
    }else {
      System.out.println("票已經(jīng)售完，"+Thread.currentThread().getName() + "未買到票");
    }
  }

b. 多個線程方法是否同步，需要判斷多個線程是否共用同一把鎖；

/**
   * 同步代碼塊
   */
  public void salTicket2() {
    synchronized (this) {
      //()中指定鎖對象，this表示當(dāng)前對象，多個線程使用同一個對象調(diào)用該方法時，是同步的
      //如果指定為 class，則該類的任意對象調(diào)用該方法都是同步的
      if (ticketNum > 0) {
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "買到第" + ticketNum-- + "張票");
        System.out.println(Thread.currentThread().getName() + "買票完成");
      } else {
        System.out.println("票已經(jīng)售完，" + Thread.currentThread().getName() + "未買到票");
      }
    }
  }

c. ReentrantLock 對象的lock 方法進(jìn)行加鎖，unLock進(jìn)行解鎖。Unlock必須放在finally中。確保能夠最終釋放鎖；

//鎖對象 private static ReentrantLock lock=new ReentrantLock();
 /**
   * 使用lock對象進(jìn)行同步,多個線程使用的是同一個lock對象，才會是同步的
   */
  public void salTicket3() {
    lock.lock();//加鎖
      if (ticketNum > 0) {
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }finally {
          lock.unlock();//釋放鎖，必須放在finally代碼塊中，以確保能夠釋放鎖
        }
        System.out.println(Thread.currentThread().getName() + "買到第" + ticketNum-- + "張票");
        System.out.println(Thread.currentThread().getName() + "買票完成");
      } else {
        System.out.println("票已經(jīng)售完，" + Thread.currentThread().getName() + "未買到票");
      }
  }

3）數(shù)據(jù)庫操作的話，也可以使用樂觀鎖或悲觀鎖的方式

4）Springmvc是如何解決線程安全問題的？

Springmvc的數(shù)據(jù)接收和傳遞都是方法級別的，使用局部變量來接收和傳遞，所以不存在線程安全問題。

四、Wait 和notify

線程間通訊的一種機(jī)制。用于手動控制線程之間的切換。在同步代碼中的鎖對象調(diào)用?？梢酝瑫r通過共享內(nèi)存對象，來實(shí)現(xiàn)數(shù)據(jù)的傳遞；

Wait 使線程進(jìn)入阻塞狀態(tài)，并釋放鎖資源；
Notify 隨機(jī)喚醒一個因wait進(jìn)入阻塞狀態(tài)的線程；
NotifyALL 喚醒所有的因wait進(jìn)入阻塞狀態(tài)的線程；

3）多線程實(shí)現(xiàn)，怎么用？

a、將單個大的任務(wù)拆分成多個小任務(wù)，使用多線程去執(zhí)行；

多線程的效率不一定比單線程的效率高；

通過線程池創(chuàng)建線程，通過實(shí)現(xiàn)runnable（無返回值）或callable（有返回值）接口來定義任務(wù)；

通過線程池的submit invoke invokeAll 等方法來執(zhí)行任務(wù)；

b、使用線程異步完成某些任務(wù)，提高并發(fā)響應(yīng)的能力，或讓線程周期性的執(zhí)行某些任務(wù)；

c、四種線程池的特點(diǎn)及其創(chuàng)建；

Java通過Executors提供四種線程池，分別為：

1）newCachedThreadPool創(chuàng)建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。

2）newFixedThreadPool 創(chuàng)建一個定長線程池，可控制線程最大并發(fā)數(shù)，超出的線程會在隊列中等待。

3）newScheduledThreadPool 創(chuàng)建一個定長線程池，支持定時及周期性任務(wù)執(zhí)行。

4）newSingleThreadExecutor 創(chuàng)建一個單線程化的線程池，它只會用唯一的工作線程來執(zhí)行任務(wù)，保證所有任務(wù)按照指定順序(FIFO, LIFO, 優(yōu)先級)執(zhí)行。

//jdk中提供的四種快速創(chuàng)建線程池的方式
    //1.定長線程池
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
    //2.緩存線程池
    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    //3.周期線程池,可用來實(shí)現(xiàn)定時任務(wù)
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
    //4.單線程線程池
    ExecutorService executorService = Executors.newSingleThreadExecutor();

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: