Java对多线程的支持（一） - Thread类、Runnable接口、Daemon线程、线程同步

Java是第一个在语言级提供了对多线程程序设计支持的语言。语言级支持是啥意思呢，就是抛开操作系统，只使用Java内置的语句就能实现多线程。一般来讲，多线程会依赖操作系统，我们要高用与系统相关的API才能创建多个线程，如在Windows中的CreateThread()函数。但JAVA就不用了。JAVA运行时系统实现了一个用于调用线程执行的线程调度器，用来决定在某一时刻哪个线程在CPU上运行。

在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的CPU时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。若要想让其支持，则必须将运行时系统运行在支持时间片轮换操作系统上。

1、Thread类和Runnable接口

在Java中实现多线程可以有2种方式，一个是让类继承Thread类，另一个是实现Runnable接口。由于Java不允许多继承，所以当我们让自定义的类继承了Thread类后就不能再继承其它类了，这样会降低日后程序的可扩展性。所以一般我们都是采用实现Runnable接口的方法让一个类具有可执行的特性。

Runnable接口只有一个方法run()，该线程启动时，JVM就会调用run()方法以执行该线程。线程类创建后，必须调用start()方法才能启动线程。如：

package cls;public class ThreadDemo{    public static void main(String[] args)    {        //创建线程类对象并实现 Runnable接口        Thread th1 = new Thread(new Runnable()        {            // 实现Runnable中的run()方法            public void run()            {                while(true)                    System.out.println("Thread1 is running !");            }        });        Thread th2 = new Thread(new Runnable()        {            public void run()            {                while(true)                    System.out.println("Thread2 is running !");            }        });                // 调用start()方法启动线程        th1.start();        th2.start();    }}

2、Daemon线程

一个Daemon线程指的是一个在后台执行服务的线程。在执行上例代码时，我们发现，当主线程(main函数)执行完th2.start()这一行的时候，主线程的代码就已经全部执行完，所以主线程退出了。但我们看到自己创建的th1和th2两个线程仍然在不停地执行，并没有退出。如果我们想让创建的线程在主函数退出后一同退出，那么就应当将我们创建的线程设置为daemon.Daemon线程当在所有的非Daemon线程都结束后自动退出。

让我们修改一下上例：

package cls;public class ThreadDemo{    public static void main(String[] args)    {        //创建线程类对象并实现 Runnable接口        Thread th1 = new Thread(new Runnable()        {            // 实现Runnable中的run()方法            public void run()            {                while(true)                    System.out.println("Thread1 is running !");            }        });        Thread th2 = new Thread(new Runnable()        {            public void run()            {                while(true)                    System.out.println("Thread2 is running !");            }        });                // 设置成daemon线程        th1.setDaemon(true);        th2.setDaemon(true);                // 调用start()方法启动线程        th1.start();        th2.start();                // 主函数睡眠一小会        try        {            Thread.currentThread().sleep(200);        }        catch(Exception e)        {            System.out.println(e.toString());        }    }}

运行后可以看到，200ms后主线程退出，相应的th1和th2也退出了。

3、线程同步

假设对象A有两个属性a和b,另有一个对象B有属性a和b,并且我们要用对象B来更新对象A。当这种更新操作完成后（对象A的a,b属性值变成了对象B的a,b属性值），则称A与B同步。

如果对象B在更新对象A时（还没更新完），又来了个对象C，对象C抢在B之前更新了A，则称A与B不同步。

讨论线程就不得不考虑线程同步的问题。当多个线程共享同一个数据时，容易造成数据的不同步。而这种不同步引发的错误往往难以修正，常常是程序在执行了几千次、几万次甚至是几年才会出现。因此线程同步就显得尤为重要。

下面写一个模拟火车站卖票的例子，故意使得线程不同步，看看会发生什么问题：

package cls;public class ThreadSynchronized{    public static void main(String[] args)    {        Ticket tk = new Ticket();                Thread th1 = new Thread(new Sold(tk));        Thread th2 = new Thread(new Sold(tk));                th1.start();        th2.start();    }}class Ticket{    int amount = 100; // 有100张票        // 卖出一张票，总票数减1，返回被卖出的票号    public int sold()    {        return amount--;    }    // 返回当前剩余票数    public int getAmount()    {        return amount;    }}// 售票线程class Sold implements Runnable{    private Ticket tk;        public Sold1(Ticket tk)    {        this.tk = tk;    }    public void run()    {        while(tk.getAmount() > 0) // 还有余票        {            try            {                Thread.currentThread().sleep(10); // 睡眠一小会            }            catch(Exception e)            {                System.out.println(e.toString());            }                        System.out.println("Thread1 sold " + tk.sold());        }    }}

执行：

我们发现，Thread1这个线程居然卖出了0这张不存在的票。售票线程在卖票前已经做了

tk.getAmount() > 0

的判断了，为什么还会卖出0这张票呢？

我们来分析下程序执行的过程：

当还剩下1这张票时，Thread1用getAmout()判断出票数大于0，则进入while循环进行售票。在还没有卖之前遇到了sleep()，于是Thread1会放弃执行机会，进入阻塞状态；这时轮到Thread2执行了，由于Thead1还没有把1卖出，因此Thread2用getAmout()的结果仍然大于0，所以就把1这张票卖出去了。这时候Thread1睡醒了，则继续从sleep()这行开始执行，而这时候票数已经变成了0，那么Thead1自然就会卖出0这张票了。

为了避免此类情况的发生，我们可以使用synchronized关键字来进行线程的同步。

synchronized关键字可以用在方法上，也可以用在语句块中。我们可以形象地把synchronized想象成一把锁。当程序执行到synchronized语句块（以后称为同步块）时，会将这个同步块的代码“上锁”，这时如果我们调用了sleep()方法或者恰好CPU分配的时间片用光了，另一个线程如果也要执行这段代码时，由于先前的线程已经对这个同步块进行了“上锁”，因此这个线程就不能执行同步块中的代码，只能等待，直到它的时间片也用完为止。这时前一个线程又得到了执行的机会，执行完代码块，它会将这个代码块“解锁”，这样别的线程才可以执行这个代码块。也就是说，一个同步块在一个时间段内只能被一个特定的线程执行，在这个线程没有执行完代码块的语句之前，其它线程是没有办法再执行这个块中的代码的。Java是通过请求一个对象的监视器实现这种功能的。一个对象只有一个监视器，当一个线程请求到后，另一个线程在这个线程归还（执行完同步块）监视器之前是无法请求到该对象的监视器的。

现在我们来改写上面的例子：

package cls;class ThreadSynchronized  {      public static void main(String[] args)      {          Ticket tk = new Ticket();          Sold sd = new Sold(tk);                    Thread th1 = new Thread(sd);          Thread th2 = new Thread(sd);                    th1.start();          th2.start();      }  }    class Ticket  {      int amount = 100; // 有100张票            // 卖出一张票，总票数减1，返回被卖出的票号      public int sold()      {          return amount--;      }      // 返回当前剩余票数      public int getAmount()      {          return amount;      }  }    // 售票线程  class Sold implements Runnable  {      private Ticket tk;            public Sold(Ticket tk)      {          this.tk = tk;      }      public void run()      {                    while(true)          {              // 同步语句块              synchronized(this)//请求 this对象的监视器              {                  if(tk.getAmount() > 0)                  {                      try                      {                          Thread.currentThread().sleep(1); // 睡眠一小会                      }                      catch(Exception e)                      {                          System.out.println(e.toString());                      }                                            System.out.println(Thread.currentThread().getName() + " sold " + tk.sold());                  }              }          }      }  } 

可以看到，问题就解决了。