利用java如何實(shí)現(xiàn)一個(gè)多線程

這篇文章給大家介紹利用java如何實(shí)現(xiàn)一個(gè)多線程，內(nèi)容非常詳細(xì)，感興趣的小伙伴們可以參考借鑒，希望對(duì)大家能有所幫助。

信陽(yáng)ssl適用于網(wǎng)站、小程序/APP、API接口等需要進(jìn)行數(shù)據(jù)傳輸應(yīng)用場(chǎng)景，ssl證書(shū)未來(lái)市場(chǎng)廣闊！成為創(chuàng)新互聯(lián)建站的ssl證書(shū)銷售渠道，可以享受市場(chǎng)價(jià)格4-6折優(yōu)惠！如果有意向歡迎電話聯(lián)系或者加微信：13518219792（備注：SSL證書(shū)合作）期待與您的合作！

java 多線程詳解

在這篇文章里，我們關(guān)注多線程。多線程是一個(gè)復(fù)雜的話題，包含了很多內(nèi)容，這篇文章主要關(guān)注線程的基本屬性、如何創(chuàng)建線程、線程的狀態(tài)切換以及線程通信。

線程是操作系統(tǒng)運(yùn)行的基本單位，它被封裝在進(jìn)程中，一個(gè)進(jìn)程可以包含多個(gè)線程。即使我們不手動(dòng)創(chuàng)造線程，進(jìn)程也會(huì)有一個(gè)默認(rèn)的線程在運(yùn)行。

對(duì)于JVM來(lái)說(shuō)，當(dāng)我們編寫(xiě)一個(gè)單線程的程序去運(yùn)行時(shí)，JVM中也是有至少兩個(gè)線程在運(yùn)行，一個(gè)是我們創(chuàng)建的程序，一個(gè)是垃圾回收。

　　線程基本信息

我們可以通過(guò)Thread.currentThread()方法獲取當(dāng)前線程的一些信息，并對(duì)其進(jìn)行修改。

我們來(lái)看以下代碼：

查看并修改當(dāng)前線程的屬性
String name = Thread.currentThread().getName();
    int priority = Thread.currentThread().getPriority();
    String groupName = Thread.currentThread().getThreadGroup().getName();
    boolean isDaemon = Thread.currentThread().isDaemon();
    System.out.println("Thread Name:" + name);
    System.out.println("Priority:" + priority);
    System.out.println("Group Name:" + groupName);
    System.out.println("IsDaemon:" + isDaemon);
    
    Thread.currentThread().setName("Test");
    Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    name = Thread.currentThread().getName();
    priority = Thread.currentThread().getPriority();
    groupName = Thread.currentThread().getThreadGroup().getName();
    isDaemon = Thread.currentThread().isDaemon();
    System.out.println("Thread Name:" + name);
    System.out.println("Priority:" + priority);

其中列出的屬性說(shuō)明如下：

  1. GroupName，每個(gè)線程都會(huì)默認(rèn)在一個(gè)線程組里，我們也可以顯式的創(chuàng)建線程組，一個(gè)線程組中也可以包含子線程組，這樣線程和線程組，就構(gòu)成了一個(gè)樹(shù)狀結(jié)構(gòu)。
  2. Name，每個(gè)線程都會(huì)有一個(gè)名字，如果不顯式指定，那么名字的規(guī)則是“Thread-xxx”。
  3. Priority，每個(gè)線程都會(huì)有自己的優(yōu)先級(jí)，JVM對(duì)優(yōu)先級(jí)的處理方式是“搶占式”的。當(dāng)JVM發(fā)現(xiàn)優(yōu)先級(jí)高的線程時(shí)，馬上運(yùn)行該線程；對(duì)于多個(gè)優(yōu)先級(jí)相等的線程，JVM對(duì)其進(jìn)行輪詢處理。Java的線程優(yōu)先級(jí)從1到10，默認(rèn)是5，Thread類定義了2個(gè)常量：MIN_PRIORITY和MAX_PRIORITY來(lái)表示最高和最低優(yōu)先級(jí)。
     

我們可以看下面的代碼，它定義了兩個(gè)不同優(yōu)先級(jí)的線程：

線程優(yōu)先級(jí)示例
public static void priorityTest()
{
  Thread thread1 = new Thread("low")
  {
    public void run()
    {
      for (int i = 0; i < 5; i++)
      {
        System.out.println("Thread 1 is running.");
      }
    }
  };
  
  Thread thread2 = new Thread("high")
  {
    public void run()
    {
      for (int i = 0; i < 5; i++)
      {
        System.out.println("Thread 2 is running.");
      }
    }
  };
  
  thread1.setPriority(Thread.MIN_PRIORITY);
  thread2.setPriority(Thread.MAX_PRIORITY);
  thread1.start();
  thread2.start();
}

從運(yùn)行結(jié)果可以看出，是高優(yōu)先級(jí)線程運(yùn)行完成后，低優(yōu)先級(jí)線程才運(yùn)行。

isDaemon，這個(gè)屬性用來(lái)控制父子線程的關(guān)系，如果設(shè)置為true，當(dāng)父線程結(jié)束后，其下所有子線程也結(jié)束，反之，子線程的生命周期不受父線程影響。

我們來(lái)看下面的例子：

IsDaemon 示例
public static void daemonTest()
{
  Thread thread1 = new Thread("daemon")
  {
    public void run()
    {
      Thread subThread = new Thread("sub")
      {
        public void run()
        {
          for(int i = 0; i < 100; i++)
          {
            System.out.println("Sub Thread Running " + i);
          }
        }
      };
      subThread.setDaemon(true);
      subThread.start();
      System.out.println("Main Thread end.");
    }
  };
  
  thread1.start();
}

上面代碼的運(yùn)行結(jié)果，在和刪除subThread.setDaemon(true);后對(duì)比，可以發(fā)現(xiàn)后者運(yùn)行過(guò)程中子線程會(huì)完成執(zhí)行后再結(jié)束，而前者中，子線程很快就結(jié)束了。

　　如何創(chuàng)建線程

上面的內(nèi)容，都是演示默認(rèn)線程中的一些信息，那么應(yīng)該如何創(chuàng)建線程呢？在Java中，我們有3種方式可以用來(lái)創(chuàng)建線程。

Java中的線程要么繼承Thread類，要么實(shí)現(xiàn)Runnable接口，我們一一道來(lái)。

　　使用內(nèi)部類來(lái)創(chuàng)建線程

我們可以使用內(nèi)部類的方式來(lái)創(chuàng)建線程，過(guò)程是聲明一個(gè)Thread類型的變量，并重寫(xiě)run方法。示例代碼如下：

使用內(nèi)部類創(chuàng)建線程
public static void createThreadByNestClass()
{
  Thread thread = new Thread()
  {
    public void run()
    {
      for (int i =0; i < 5; i++)
      {
        System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
      }
      System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
    }
  };
  thread.start();
}

　　繼承Thread以創(chuàng)建線程

我們可以從Thread中派生一個(gè)類，重寫(xiě)其run方法，這種方式和上面相似。示例代碼如下：

派生Thread類以創(chuàng)建線程
class MyThread extends Thread
{
  public void run()
  {
    for (int i =0; i < 5; i++)
    {
      System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
    }
    System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
  }
}


public static void createThreadBySubClass()
{
  MyThread thread = new MyThread();
  thread.start();
}

　　實(shí)現(xiàn)Runnable接口以創(chuàng)建線程

我們可以定義一個(gè)類，使其實(shí)現(xiàn)Runnable接口，然后將該類的實(shí)例作為構(gòu)建Thread變量構(gòu)造函數(shù)的參數(shù)。示例代碼如下：

實(shí)現(xiàn)Runnable接口以創(chuàng)建線程
class MyRunnable implements Runnable
{
  public void run() 
  {
    for (int i =0; i < 5; i++)
    {
      System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
    }
    System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
  }
}


public static void createThreadByRunnable()
{
  MyRunnable runnable = new MyRunnable();
  Thread thread = new Thread(runnable);
  thread.start();
}

上述3種方式都可以創(chuàng)建線程，而且從示例代碼上看，線程執(zhí)行的功能是一樣的，那么這三種創(chuàng)建方式有什么不同呢？

這涉及到Java中多線程的運(yùn)行模式，對(duì)于Java來(lái)說(shuō)，多線程在運(yùn)行時(shí)，有“多對(duì)象多線程”和“單對(duì)象多線程”的區(qū)別：

  1. 多對(duì)象多線程，程序在運(yùn)行過(guò)程中創(chuàng)建多個(gè)線程對(duì)象，每個(gè)對(duì)象上運(yùn)行一個(gè)線程。
  2. 單對(duì)象多線程，程序在運(yùn)行過(guò)程中創(chuàng)建一個(gè)線程對(duì)象，在其上運(yùn)行多個(gè)線程。

顯然，從線程同步和調(diào)度的角度來(lái)看，多對(duì)象多線程要簡(jiǎn)單一些。上述3種線程創(chuàng)建方式，前兩種都屬于“多對(duì)象多線程”，第三種既可以使用“多對(duì)象多線程”，也可以使用“單對(duì)象單線程”。

我們來(lái)看下面的示例代碼，里面會(huì)用到Object.notify方法，這個(gè)方法會(huì)喚醒對(duì)象上的一個(gè)線程；而Object.notifyAll方法，則會(huì)喚醒對(duì)象上的所有線程。

notify示例
public class NotifySample {
  
  public static void main(String[] args) throws InterruptedException
  {
    notifyTest();
    notifyTest2();
    notifyTest3();
  }
  
  private static void notifyTest() throws InterruptedException
  {
    MyThread[] arrThreads = new MyThread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrThreads[i] = new MyThread();
      arrThreads[i].id = i;
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);
    for (int i = 0; i < arrThreads.length; i++)
    {
      synchronized(arrThreads[i])
      {
        arrThreads[i].notify();
      }
    }
  }
  
  private static void notifyTest2() throws InterruptedException
  {
    MyRunner[] arrMyRunners = new MyRunner[3];
    Thread[] arrThreads = new Thread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrMyRunners[i] = new MyRunner();
      arrMyRunners[i].id = i;
      arrThreads[i] = new Thread(arrMyRunners[i]);
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);
    for (int i = 0; i < arrMyRunners.length; i++)
    {
      synchronized(arrMyRunners[i])
      {
        arrMyRunners[i].notify();
      }
    }
  }
  
  private static void notifyTest3() throws InterruptedException
  {
    MyRunner runner = new MyRunner();
    Thread[] arrThreads = new Thread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrThreads[i] = new Thread(runner);
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);

    synchronized(runner)
    {
      runner.notifyAll();
    }
  }
}

class MyThread extends Thread
{
  public int id = 0;
  public void run()
  {
    System.out.println("第" + id + "個(gè)線程準(zhǔn)備休眠5分鐘。");
    try
    {
      synchronized(this)
      {
        this.wait(5*60*1000);
      }
    }
    catch(InterruptedException ex)
    {
      ex.printStackTrace();
    }
    System.out.println("第" + id + "個(gè)線程被喚醒。");
  }
}

class MyRunner implements Runnable
{
  public int id = 0;
  public void run() 
  {
    System.out.println("第" + id + "個(gè)線程準(zhǔn)備休眠5分鐘。");
    try
    {
      synchronized(this)
      {
        this.wait(5*60*1000);
      }
    }
    catch(InterruptedException ex)
    {
      ex.printStackTrace();
    }
    System.out.println("第" + id + "個(gè)線程被喚醒。");
  }
  
}

示例代碼中，notifyTest()和notifyTest2()是“多對(duì)象多線程”，盡管notifyTest2()中的線程實(shí)現(xiàn)了Runnable接口，但是它里面定義Thread數(shù)組時(shí)，每個(gè)元素都使用了一個(gè)新的Runnable實(shí)例。notifyTest3()屬于“單對(duì)象多線程”，因?yàn)槲覀冎欢x了一個(gè)Runnable實(shí)例，所有的線程都會(huì)使用這個(gè)實(shí)例。

notifyAll方法適用于“單對(duì)象多線程”的情景，因?yàn)閚otify方法只會(huì)隨機(jī)喚醒對(duì)象上的一個(gè)線程。

線程的狀態(tài)切換

對(duì)于線程來(lái)講，從我們創(chuàng)建它一直到線程運(yùn)行結(jié)束，在這個(gè)過(guò)程中，線程的狀態(tài)可能是這樣的：

  1. 創(chuàng)建：已經(jīng)有Thread實(shí)例了， 但是CPU還有為其分配資源和時(shí)間片。
  2. 就緒：線程已經(jīng)獲得了運(yùn)行所需的所有資源，只等CPU進(jìn)行時(shí)間調(diào)度。
  3. 運(yùn)行：線程位于當(dāng)前CPU時(shí)間片中，正在執(zhí)行相關(guān)邏輯。
  4. 休眠：一般是調(diào)用Thread.sleep后的狀態(tài)，這時(shí)線程依然持有運(yùn)行所需的各種資源，但是不會(huì)被CPU調(diào)度。
  5. 掛起：一般是調(diào)用Thread.suspend后的狀態(tài)，和休眠類似，CPU不會(huì)調(diào)度該線程，不同的是，這種狀態(tài)下，線程會(huì)釋放所有資源。
  6. 死亡：線程運(yùn)行結(jié)束或者調(diào)用了Thread.stop方法。
     

下面我們來(lái)演示如何進(jìn)行線程狀態(tài)切換，首先我們會(huì)用到下面方法：

  1. Thread()或者Thread(Runnable)：構(gòu)造線程。
  2. Thread.start：?jiǎn)?dòng)線程。
  3. Thread.sleep：將線程切換至休眠狀態(tài)。
  4. Thread.interrupt：中斷線程的執(zhí)行。
  5. Thread.join：等待某線程結(jié)束。
  6. Thread.yield：剝奪線程在CPU上的執(zhí)行時(shí)間片，等待下一次調(diào)度。
  7. Object.wait：將Object上所有線程鎖定，直到notify方法才繼續(xù)運(yùn)行。
  8. Object.notify：隨機(jī)喚醒Object上的1個(gè)線程。
  9. Object.notifyAll：?jiǎn)拘袿bject上的所有線程。
     

下面，就是演示時(shí)間啦?。?！

　　線程等待與喚醒

這里主要使用Object.wait和Object.notify方法，請(qǐng)參見(jiàn)上面的notify實(shí)例。需要注意的是，wait和notify都必須針對(duì)同一個(gè)對(duì)象，當(dāng)我們使用實(shí)現(xiàn)Runnable接口的方式來(lái)創(chuàng)建線程時(shí)，應(yīng)該是在Runnable對(duì)象而非Thread對(duì)象上使用這兩個(gè)方法。

　　線程的休眠與喚醒

Thread.sleep實(shí)例
public class SleepSample {
  
  public static void main(String[] args) throws InterruptedException
  {
    sleepTest();
  }
  
  private static void sleepTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        System.out.println("線程 " + Thread.currentThread().getName() + "將要休眠5分鐘。");
        try
        {
          Thread.sleep(5*60*1000);
        }
        catch(InterruptedException ex)
        {
          System.out.println("線程 " + Thread.currentThread().getName() + "休眠被中斷。");
        }
        System.out.println("線程 " + Thread.currentThread().getName() + "休眠結(jié)束。");
      }
    };
    thread.setDaemon(true);
    thread.start();
    Thread.sleep(500);
    thread.interrupt();
  }

}

線程在休眠過(guò)程中，我們可以使用Thread.interrupt將其喚醒，這時(shí)線程會(huì)拋出InterruptedException。

　　線程的終止

雖然有Thread.stop方法，但該方法是不被推薦使用的，我們可以利用上面休眠與喚醒的機(jī)制，讓線程在處理IterruptedException時(shí)，結(jié)束線程。

Thread.interrupt示例
public class StopThreadSample {

  public static void main(String[] args) throws InterruptedException
  {
    stopTest();
  }
  
  private static void stopTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        System.out.println("線程運(yùn)行中。");
        try
        {
          Thread.sleep(1*60*1000);
        }
        catch(InterruptedException ex)
        {
          System.out.println("線程中斷，結(jié)束線程");
          return;
        }
        System.out.println("線程正常結(jié)束。");
      }
    };
    thread.start();
    Thread.sleep(500);
    thread.interrupt();
  }
}

線程的同步等待

當(dāng)我們?cè)谥骶€程中創(chuàng)建了10個(gè)子線程，然后我們期望10個(gè)子線程全部結(jié)束后，主線程在執(zhí)行接下來(lái)的邏輯，這時(shí)，就該Thread.join登場(chǎng)了。

Thread.join示例
public class JoinSample {

  public static void main(String[] args) throws InterruptedException
  {
    joinTest();
  }
  
  private static void joinTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        try
        {
          for(int i = 0; i < 5; i++)
          {
            System.out.println("線程在運(yùn)行。");
            Thread.sleep(1000);
          }
        }
        catch(InterruptedException ex)
        {
          ex.printStackTrace();
        }
      }
    };
    thread.setDaemon(true);
    thread.start();
    Thread.sleep(1000);
    thread.join();
    System.out.println("主線程正常結(jié)束。");
  }
}

我們可以試著將thread.join();注釋或者刪除，再次運(yùn)行程序，就可以發(fā)現(xiàn)不同了。

　　線程間通信

我們知道，一個(gè)進(jìn)程下面的所有線程是共享內(nèi)存空間的，那么我們?nèi)绾卧诓煌木€程之間傳遞消息呢？在回顧 Java I/O時(shí)，我們談到了PipedStream和PipedReader，這里，就是它們發(fā)揮作用的地方了。

下面的兩個(gè)示例，功能完全一樣，不同的是一個(gè)使用Stream，一個(gè)使用Reader/Writer。

PipeInputStream/PipedOutpueStream 示例
public static void communicationTest() throws IOException, InterruptedException
{
  final PipedOutputStream pos = new PipedOutputStream();
  final PipedInputStream pis = new PipedInputStream(pos);
  
  Thread thread1 = new Thread()
  {
    public void run()
    {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      try
      {
        while(true)
        {
          String message = br.readLine();
          pos.write(message.getBytes());
          if (message.equals("end")) break;
        }
        br.close();
        pos.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };
  
  Thread thread2 = new Thread()
  {
    public void run()
    {
      byte[] buffer = new byte[1024];
      int bytesRead = 0;
      try
      {
        while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1)
        {
          System.out.println(new String(buffer));
          if (new String(buffer).equals("end")) break;
          buffer = null;
          buffer = new byte[1024];
        }
        pis.close();
        buffer = null;
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };
  
  thread1.setDaemon(true);
  thread2.setDaemon(true);
  thread1.start();
  thread2.start();
  thread1.join();
  thread2.join();
}
PipedReader/PipedWriter 示例
private static void communicationTest2() throws InterruptedException, IOException
{
  final PipedWriter pw = new PipedWriter();
  final PipedReader pr = new PipedReader(pw);
  final BufferedWriter bw = new BufferedWriter(pw);
  final BufferedReader br = new BufferedReader(pr);
  
  Thread thread1 = new Thread()
  {
    public void run()
    {
      
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      try
      {
        while(true)
        {
          String message = br.readLine();
          bw.write(message);
          bw.newLine();
          bw.flush();
          if (message.equals("end")) break;
        }
        br.close();
        pw.close();
        bw.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };
  
  Thread thread2 = new Thread()
  {
    public void run()
    {
      
      String line = null;
      try
      {
        while((line = br.readLine()) != null)
        {
          System.out.println(line);
          if (line.equals("end")) break;
        }
        br.close();
        pr.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };
  
  thread1.setDaemon(true);
  thread2.setDaemon(true);
  thread1.start();
  thread2.start();
  thread1.join();
  thread2.join();
}

關(guān)于利用java如何實(shí)現(xiàn)一個(gè)多線程就分享到這里了，希望以上內(nèi)容可以對(duì)大家有一定的幫助，可以學(xué)到更多知識(shí)。如果覺(jué)得文章不錯(cuò)，可以把它分享出去讓更多的人看到。

文章題目：利用java如何實(shí)現(xiàn)一個(gè)多線程
標(biāo)題網(wǎng)址：http://www.muchs.cn/article12/gcegdc.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供電子商務(wù)、網(wǎng)站排名、移動(dòng)網(wǎng)站建設(shè)、品牌網(wǎng)站建設(shè)、網(wǎng)站導(dǎo)航、品牌網(wǎng)站設(shè)計(jì)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源： 創(chuàng)新互聯(lián)

搜索引擎優(yōu)化