Java中可运行接口的完整指南

DebugUsery
284 阅读4分钟

在Java中，只有通过 接口才能实现多重继承的概念 。接口是一个抽象的集合（标准方法不存在）。 除非实现接口的类是抽象的，否则所有的接口方法都需要在该类中定义。 一个类使用关键字 implements来实现一个接口 。

Java中的Runnable接口

Java.lang.Runnable是由实例打算由线程执行的类所要实现的接口。有两种方法可以启动一个新的线程 - 子类化线程 和实现Runnable接口。

如果只通过重写Runnable的run()方法就可以完成任务，那么就没有必要再子类化Thread。

语法

class <class_name> implements <interface_name>

请看下面的代码示例：

//creating an interface 
interface java 
{
  static final String lan = "Java";  
  public void display();
}
 
 //driver class 
public class example implements java 
{
  public static void main(String []args) 
  {
    example obj = new example();
    obj.display();
  }
  public void display() 
  {
    System.out.println(lan + " is a programming language");
  }
}

请看输出：

Runnable Interface in Java

Java中的线程

Java提供了对多线程编程的支持。一个多线程程序包含两个或多个可以同时运行的轻量级部分。多线程程序的这些部分被称为线程。每个线程都有不同的执行流程。

在每个Java程序的开始，有一个线程开始运行，它被称为程序的主线程，因为它是程序启动时执行的线程。

语法

thread t = new thread (new RunnableTask ());
t.start();

请看下面的程序：

public class threading extends Thread
{  
  public void run()
  {  
    System.out.println("Thread is running.");  
  }   
  public static void main(String args[])
  {  
     threading obj=new threading();   
     obj.start();  
  }  
}

见下面的输出：

Thread in Java

Runnable接口

Runnable接口是每个Java平台都有的一个基本Java接口。它概述了一个类，其实例可以作为一个线程执行。 java.lang.Runnable 接口只有一个方法 run()。

Runnable接口的基本外观：

public interface Runnable () {
   public void run ();
}

运行()

它在线程启动时被调用。代码必须放在我们希望由线程执行的方法里面。runnable 接口用于创建Java中的线程。在Java中，有两种方法可以生成线程。一种方法是： 通过实现可运行接口来 创建 线程。

使用Runnable创建线程的步骤

  1. 创建一个实现Runnable的类。
  2. 在Runnable类中使用runnable方法。
  3. 创建一个线程类的实例，并将我们的Runnable对象作为参数传递给其构造函数。创建的线程对象可以运行runnable类。
  4. 调用线程对象的start方法。

请看下面的代码：

public class threading_2 implements Runnable
{  
  public void run()
  {  
    System.out.println("Thread is running.");  
  }   
  public static void main(String args[])
  {  
     threading_2 obj=new threading_2();  
     Thread t =new Thread(obj);  
     t.start();  
  }  
}

请看输出结果：

Steps to create a thread using RunnableRunnable接口是任何打算由线程执行的对象的一个主要模板。它定义了单一的方法run()，意在包含一个由线程执行的代码。

对于任何实例需要被执行的类，线程都应该实现Runnable接口。

一个Thread 类本身就实现了一个Runnable，并有一个空的run()方法的实现。

对于创建新的线程，创建一个实现Runnable接口的类的实例，然后将该实例传递给Thread(Runnable target)构造函数。

Runnable和Thread类，哪个更好？

正如我们已经知道的，在Java中存在两种方法来创建一个线程。其中一种方法是通过扩展线程类来创建线程，这种方法是最小的，因为一旦我们从线程类中扩展了我们的类，我们就不能从其他任何类中扩展，因为Java不允许多重继承。

所以，一般来说，我们应该总是使用一个可运行的接口来创建线程。然而，这种方法是相当灵活的。它允许我们从任何其他类中扩展。

所以，一般来说，你应该总是使用Runnable对象来创建一个线程。然而，这个方法更加灵活。它允许你的类从任何其他类中扩展。此外，你可以使用匿名类语法和Java 8的Lambda表达式与Runnable一起使用，使你的代码更加简洁。

在Java中加入线程

Java.lang.thread 类提供了join()方法，它可以让一个线程等待，直到另一个线程完成其执行。它可以停止当前线程的执行，直到被加入的线程死亡。

语法

public void join () throws InterruptedException
public void join (long milliseconds) throws InterruptedException

请看下面的代码：

public class Joinmethod_ex extends Thread
{  
 public void run()
 {  
  for(int i=1;i<=5;i++)
  {  
   try
   {  
     Thread.sleep(500);  
   }
   catch(Exception e)
   {
     System.out.println(e);
   }  
   System.out.println(i);  
  }  
 }  
 public static void main(String args[])
 {  
    Joinmethod_ex t1=new Joinmethod_ex();  
    Joinmethod_ex t2=new Joinmethod_ex();  
    Joinmethod_ex t3=new Joinmethod_ex();  
    t1.start();  
    try
    {  
	t1.join();  
    }
    catch(Exception e)
    {
	System.out.println(e);
    }  
    t2.start();  
    t3.start();  
 } 
}

请看输出：

Joining Thread in Java

正如你在上面的程序中看到的，线程t2和t3的执行被停止，直到线程t1死亡。

所以， join()方法允许一个线程等待另一个线程的完成。在下面的例子中，线程2通过调用Thread.join(1000)等待线程1的完成，等待了1000毫秒，然后开始执行。

本教程就到此为止。

avatar
文章
阅读
粉丝