在Java中创建线程有两种方式，一种是继承Thread，另一种是实现Runnable接口，Thread实际上也实现了Runnable接口。

Thread

构造方法

方法摘要

使用示例

public class ThreadDemo
{
   public static void main(String[] args)
   {
      PrintThread thread1 = new PrintThread();
      PrintThread thread2 = new PrintThread();
      // 通过start方法启动线程
      thread1.start();
      thread2.start();
   }
}

/**
 * 继承Thread
 * 
 * @author jianggujin
 * 
 */
class PrintThread extends Thread
{
   /**
    * 重写run方法，线程执行的逻辑写在该方法内
    */
   @Override
   public void run()
   {
      for (int i = 0; i < 10; i++)
      {
         try
         {
            // 使线程休眠100毫秒，使结果更直观
            Thread.sleep(100);
         }
         catch (InterruptedException e)
         {
            e.printStackTrace();
         }
         System.out.println(getName() + ":" + i);
      }
   }
}

运行结果如下：
Thread-1:0
Thread-0:0
Thread-0:1
Thread-1:1
Thread-0:2
Thread-1:2
Thread-0:3
Thread-1:3
Thread-0:4
Thread-1:4
Thread-1:5
Thread-0:5
Thread-1:6
Thread-0:6
Thread-0:7
Thread-1:7
Thread-0:8
Thread-1:8
Thread-1:9
Thread-0:9

在上面的示例中，我们使用了继承Thread的方式创建了线程对象并通过start()方法启动了线程，在例子中，我们启动了两个线程，线程只是简单的输出一句话，通过查看运行结果，我们可以发现两个线程是交错执行的。

Runnable

方法摘要

使用示例

public class ThreadDemo
{
   public static void main(String[] args)
   {
      PrintThread thread1 = new PrintThread("Thread-0");
      PrintThread thread2 = new PrintThread("Thread-1");
      // 使用该种方式启动线程
      new Thread(thread1).start();
      new Thread(thread2).start();
   }
}

/**
 * 实现Runnable接口
 * 
 * @author jianggujin
 * 
 */
class PrintThread implements Runnable
{
   // 用于标识线程
   private String name;

   public PrintThread(String name)
   {
      this.name = name;
   }

   /**
    * 实现run方法，线程执行的逻辑写在该方法内
    */
   @Override
   public void run()
   {
      for (int i = 0; i < 10; i++)
      {
         try
         {
            // 使线程休眠100毫秒，使结果更直观
            Thread.sleep(100);
         }
         catch (InterruptedException e)
         {
            e.printStackTrace();
         }
         System.out.println(getName() + ":" + i);
      }
   }

   public String getName()
   {
      return name;
   }
}

运行结果：
Thread-0:0
Thread-1:0
Thread-1:1
Thread-0:1
Thread-0:2
Thread-1:2
Thread-0:3
Thread-1:3
Thread-0:4
Thread-1:4
Thread-1:5
Thread-0:5
Thread-0:6
Thread-1:6
Thread-0:7
Thread-1:7
Thread-0:8
Thread-1:8
Thread-1:9
Thread-0:9

join()

有的时候，我们希望当一个线程执行完后，在继续执行其他线程，比如一些初始化工作。这个时候我们可以使用join()方法，join()方法可以等待该线程终止。

使用示例

public class ThreadDemo
{
   public static void main(String[] args)
   {
      PrintThread thread1 = new PrintThread();
      PrintThread thread2 = new PrintThread();
      // 通过start方法启动线程
      thread1.start();
      try
      {
         //等待线程执行结束
         thread1.join();
      }
      catch (InterruptedException e)
      {
         e.printStackTrace();
      }
      thread2.start();
   }
}

/**
 * 继承Thread
 * 
 * @author jianggujin
 * 
 */
class PrintThread extends Thread
{
   /**
    * 重写run方法，线程执行的逻辑写在该方法内
    */
   @Override
   public void run()
   {
      for (int i = 0; i < 10; i++)
      {
         try
         {
            // 使线程休眠100毫秒，使结果更直观
            Thread.sleep(100);
         }
         catch (InterruptedException e)
         {
            e.printStackTrace();
         }
         System.out.println(getName() + ":" + i);
      }
   }
}

运行结果：
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-1:5
Thread-1:6
Thread-1:7
Thread-1:8
Thread-1:9

通过运行结果我们可以看到，当我们使用join方法后，会等待线程执行结束再继续执行另一个线程。