Javaのレビューに基づいたマルチスレッドの詳細な説明

スレッドは、オペレーティング システム操作の基本単位であり、プロセス内にカプセル化されます。スレッドを手動で作成しなくても、プロセスではデフォルトのスレッドが実行されます。

JVM の場合、実行するシングルスレッド プログラムを作成すると、JVM 内で少なくとも 2 つのスレッドが実行されます。1 つは作成したプログラムで、もう 1 つはガベージ コレクションです。

基本的なスレッド情報

Thread.currentThread() メソッドを通じて現在のスレッドに関する情報を取得し、変更することができます。

次のコードを見てみましょう:

查看并修改当前线程的属性
 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);

リストされた属性は次のとおりです:

GroupName、各スレッドはデフォルトでスレッド グループに属します。スレッド グループ、スレッド グループを明示的に作成することもできます。サブスレッド グループを含めることもできるため、スレッドとスレッド グループはツリー構造を形成します。

名前、各スレッドには名前が付けられます。明示的に指定しない場合、名前のルールは「Thread-xxx」です。

優先順位。各スレッドには独自の優先順位があり、JVM の優先順位の処理方法は「プリエンプティブ」です。 JVM は優先度の高いスレッドを見つけると、すぐにそのスレッドを実行し、同じ優先度を持つ複数のスレッドに対してポーリングを行います。 Java のスレッド優先順位の範囲は 1 ～ 10 で、デフォルトは 5 です。Thread クラスは、最高と最低の優先順位を表す MIN_PRIORITY と MAX_PRIORITY という 2 つの定数を定義します。

異なる優先度を持つ 2 つのスレッドを定義する次のコードを見ることができます:

线程优先级示例
 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();
 }

実行結果からわかるように、優先度の低いスレッドは、優先度の高いスレッドの実行が完了した後にのみ実行されます。
isDaemon、この属性は親スレッドと子スレッド間の関係を制御するために使用されます。これを true に設定すると、親スレッドが終了すると、その下のすべての子スレッドも終了しません。親スレッドの影響を受けます。
次の例を見てみましょう:

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();
 }

上記のコードの実行結果と、subThread.setDaemon(true); を削除した後の結果を比較すると、後者ではサブスレッドが実行を完了して終了することがわかります。前者の場合、子スレッドはすぐに終了します。

スレッドの作成方法

上記のコンテンツはすべてデフォルトのスレッドの情報を示しています。では、どのようにスレッドを作成すればよいでしょうか? Java では、スレッドを作成する方法が 3 つあります。

Java のスレッドは、Thread クラスを継承するか、Runnable インターフェイスを実装します。1 つずつ見ていきましょう。

内部クラスを使用してスレッドを作成する

内部クラスを使用してスレッドを作成するプロセスは、Thread 型の変数を宣言し、run メソッドをオーバーライドすることです。サンプルコードは次のとおりです:

使用内部类创建线程
 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 を継承してスレッドを作成します

上記と同様の方法で Thread からクラスを派生し、その run メソッドをオーバーライドできます。サンプルコードは次のとおりです:

派生Thread类以创建线程
 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();
 }

Runnable インターフェイスを実装してスレッドを作成します

Runnable インターフェイスを実装するようにクラスを定義し、このクラスのインスタンスをパラメータとして使用して Thread 変数コンストラクターを構築できます。サンプルコードは以下の通りです。

实现Runnable接口以创建线程
 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つの方法でスレッドを作成できますが、サンプルコードを見るとスレッドが実行する機能は同じですが、これら3つの作成方法の違いは何でしょうか？

これには、Java でのマルチスレッドの実行モードが関係します。Java の場合、マルチスレッドが実行されている場合、「マルチオブジェクト マルチスレッド」と「単一オブジェクト マルチスレッド」には違いがあります。

マルチオブジェクト マルチスレッド 、プログラムは実行中に複数のスレッド オブジェクトを作成し、各オブジェクトで 1 つのスレッドが実行されます。
単一オブジェクトのマルチスレッド。プログラムは実行中にスレッド オブジェクトを作成し、その上で複数のスレッドを実行します。

明らかに、スレッドの同期とスケジューリングの観点からは、マルチオブジェクトのマルチスレッドの方が簡単です。上記 3 つのスレッド作成方法のうち、最初の 2 つは「マルチオブジェクト マルチスレッド」で、3 つ目は「マルチオブジェクト マルチスレッド」または「単一オブジェクト シングル スレッド」のいずれかを使用できます。

以下のサンプル コードを見てみましょう。このコードは Object.notify メソッドを使用し、オブジェクトのスレッドを起動し、Object.notifyAll メソッドはオブジェクトのすべてのスレッドを起動します。

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 + "个线程准备休眠5分钟。");
         try
         {
             synchronized(this)
             {
                 this.wait(5*60*1000);
             }
         }
         catch(InterruptedException ex)
         {
             ex.printStackTrace();
         }
         System.out.println("第" + id + "个线程被唤醒。");
     }
 }

 class MyRunner implements Runnable
 {
     public int id = 0;
     public void run() 
     {
         System.out.println("第" + id + "个线程准备休眠5分钟。");
         try
         {
             synchronized(this)
             {
                 this.wait(5*60*1000);
             }
         }
         catch(InterruptedException ex)
         {
             ex.printStackTrace();
         }
         System.out.println("第" + id + "个线程被唤醒。");
     }

 }

サンプルコードでは、notifyTest()とnotifyTest2()は「マルチオブジェクトマルチスレッド」となっていますが、notifyTest2()のスレッドはRunnableインターフェースを実装していますが、その中でThread配列を定義する際には、各要素は新しいインターフェースを使用します。実行可能なインスタンス。 NoticeTest3() は、Runnable インスタンスを 1 つだけ定義し、すべてのスレッドがこのインスタンスを使用するため、「単一オブジェクト マルチスレッド」に属します。

notifyAll メソッドは、オブジェクト上の 1 つのスレッドのみをランダムに起動するため、「単一オブジェクトの複数のスレッド」シナリオに適しています。

スレッドステータスの切り替え

スレッドの場合、スレッドの作成時から実行中のスレッドの終了まで、このプロセス中にスレッドのステータスは次のようになります:

创建：已经有Thread实例了， 但是CPU还有为其分配资源和时间片。
就绪：线程已经获得了运行所需的所有资源，只等CPU进行时间调度。
运行：线程位于当前CPU时间片中，正在执行相关逻辑。
休眠：一般是调用Thread.sleep后的状态，这时线程依然持有运行所需的各种资源，但是不会被CPU调度。
挂起：一般是调用Thread.suspend后的状态，和休眠类似，CPU不会调度该线程，不同的是，这种状态下，线程会释放所有资源。
死亡：线程运行结束或者调用了Thread.stop方法。

下面我们来演示如何进行线程状态切换，首先我们会用到下面方法：

Thread()或者Thread(Runnable)：构造线程。
Thread.start：启动线程。
Thread.sleep：将线程切换至休眠状态。
Thread.interrupt：中断线程的执行。
Thread.join：等待某线程结束。
Thread.yield：剥夺线程在CPU上的执行时间片，等待下一次调度。
Object.wait：将Object上所有线程锁定，直到notify方法才继续运行。
Object.notify：随机唤醒Object上的1个线程。
Object.notifyAll：唤醒Object上的所有线程。

下面，就是演示时间啦！！！

线程等待与唤醒

这里主要使用Object.wait和Object.notify方法，请参见上面的notify实例。需要注意的是，wait和notify都必须针对同一个对象，当我们使用实现Runnable接口的方式来创建线程时，应该是在Runnable对象而非Thread对象上使用这两个方法。

线程的休眠与唤醒

Thread.sleep实例
 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() + "休眠结束。");
             }
         };
         thread.setDaemon(true);
         thread.start();
         Thread.sleep(500);
         thread.interrupt();
     }

 }

线程在休眠过程中，我们可以使用Thread.interrupt将其唤醒，这时线程会抛出InterruptedException。

线程的终止

虽然有Thread.stop方法，但该方法是不被推荐使用的，我们可以利用上面休眠与唤醒的机制，让线程在处理IterruptedException时，结束线程。

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("线程运行中。");
                 try
                 {
                     Thread.sleep(1*60*1000);
                 }
                 catch(InterruptedException ex)
                 {
                     System.out.println("线程中断，结束线程");
                     return;
                 }
                 System.out.println("线程正常结束。");
             }
         };
         thread.start();
         Thread.sleep(500);
         thread.interrupt();
     }
 }

线程的同步等待

当我们在主线程中创建了10个子线程，然后我们期望10个子线程全部结束后，主线程在执行接下来的逻辑，这时，就该Thread.join登场了。

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("线程在运行。");
                         Thread.sleep(1000);
                     }
                 }
                 catch(InterruptedException ex)
                 {
                     ex.printStackTrace();
                 }
             }
         };
         thread.setDaemon(true);
         thread.start();
         Thread.sleep(1000);
         thread.join();
         System.out.println("主线程正常结束。");
     }
 }

我们可以试着将thread.join();注释或者删除，再次运行程序，就可以发现不同了。

线程间通信

我们知道，一个进程下面的所有线程是共享内存空间的，那么我们如何在不同的线程之间传递消息呢？在回顾 Java I/O时，我们谈到了PipedStream和PipedReader，这里，就是它们发挥作用的地方了。

下面的两个示例，功能完全一样，不同的是一个使用Stream，一个使用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();
 }

 以上就是基于Java回顾之多线程详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！