java多线程功力

一、操作系统中线程和进程的概念

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。多线程编程可以使程序具有两条或两条以上的并发执行线索。

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

“同时”执行是人的感觉，在线程之间实际上轮换执行。

例如：网上购物时邮件通知程序，用户单击提交按钮确认订单时，一方面要显示信息提示用户订单已经确认，一方面应该自动给用户发送一份电子邮件。

二、Java中的线程

 使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。

Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。

一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。

一旦创建一个新的线程，就产生一个新的调用栈。

线程总体分两类：用户线程和守候线程。

当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。

二、实例化线程

1、继承java.lang.Thread的类，那么该类对象便具有了线程的能力。此类的自身对象就是线程对象，在创建线程对象时只需要创建自身的对象即可。

要重写继承的run()方法，run()方法中的代码就是线程所要执行任务的描述。 
 一旦线程启动，run方法中的代码将成为一条独立的执行线索。
  注意，重写后的run方法虽然具有成为执行线索的能力，但也可以作为一般的方法调用，直接调用run方法并不产生新的执行线索

2、实现了java.lang.Runnable接口的类，其自身对象并不是一个线程，只是在该类中通过实现run方法指出了线程需要完成的任务。
若想得到一个线程，必须创建Thread类或其子类对象，这时就要使用Thread类的特定构造器来完成这个工作。

//创建实现Runnable接口的类的对象。
MyRunnable mr=new  MyRunnable();
Thread t=new Thread(mr);
这种方式实际上是告诉线程对象要执行的任务run方法在哪里。
实现Runnable接口的类的对象只是指出了线程需要完成的任务，其本身并不是线程对象。

三、启动线程

在线程的Thread对象上调用start()方法，就启动线程了，又开辟了另一条执行线索。

在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。

在调用start()方法之后：发生了一系列复杂的事情

启动新的执行线程（具有新的调用栈）；

该线程从新状态转移到可运行状态；

当该线程获得机会执行时，其目标run()方法将运行。

注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称(和签名)。

四、例子

1、实现Runnable接口的多线程例子

/** 
* 实现Runnable接口的类 
* 
* @author leizhimin 2008-9-13 18:12:10 
*/ 
public class DoSomething implements Runnable { 
    private String name;

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

public void run() { 
        for (int i = 0; i < 5; i++) { 
            for (long k = 0; k < 100000000; k++) ; 
            System.out.println(name + ": " + i); 
        } 
    } 
}

/** 
* 测试Runnable类实现的多线程程序 
* 
*/ 
public class TestRunnable { 
    public static void main(String[] args) { 
        DoSomething ds1 = new DoSomething("阿三"); 
        DoSomething ds2 = new DoSomething("李四");

Thread t1 = new Thread(ds1); 
        Thread t2 = new Thread(ds2);

t1.start(); 
        t2.start(); 
    } 
}

执行结果：

李四: 0 
阿三: 0 
李四: 1 
阿三: 1 
李四: 2 
李四: 3 
阿三: 2 
李四: 4 
阿三: 3 
阿三: 4

Process finished with exit code 0

2、扩展Thread类实现的多线程例子

/** 
* 测试扩展Thread类实现的多线程程序 
* 
*/ 
public class TestThread extends Thread{ 
    public TestThread(String name) { 
        super(name); 
    }

public void run() { 
        for(int i = 0;i<5;i++){ 
            for(long k= 0; k <100000000;k++); 
            System.out.println(this.getName()+" :"+i); 
        } 
    }

public static void main(String[] args) { 
        Thread t1 = new TestThread("阿三"); 
        Thread t2 = new TestThread("李四"); 
        t1.start(); 
        t2.start(); 
    } 
}

执行结果：

阿三 :0 
李四 :0 
阿三 :1 
李四 :1 
阿三 :2 
李四 :2 
阿三 :3 
阿三 :4 
李四 :3 
李四 :4

五、一些常见问题

1、线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字不确定。

3、获取当前线程的对象的方法是：Thread.currentThread()；

4、在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。

5、当线程目标run()方法结束时该线程完成。

6、一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

7、线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。

众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

8、尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列一个队列的事实。

9、尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

要理解线程调度的原理，以及线程执行过程，必须理解线程栈模型。

线程栈是指某时内存中线程调度的栈信息，当前调用的方法总是位于栈顶。线程栈的内容是随着程序的运行动态变化的，因此研究线程栈必须选择一个运行的时刻（实际上指代码运行到什么地方)。

下面通过一个示例性的代码说明线程（调用）栈的变化过程。

这幅图描述在代码执行到两个不同时刻1、2时候，虚拟机线程调用栈示意图。

当程序执行到t.start();时候，程序多出一个分支（增加了一个调用栈B），这样，栈A、栈B并行执行。

从这里就可以看出方法调用和线程启动的区别了。

一、线程状态

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：

1、新状态：线程对象已经创建，还没有在其上调用start()方法，不能被线程调度程序调度。

2、可运行状态：线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。这种状态下其随时可能被线程调度程序调度，获取CPU执行时间而执行，同时可能有多个线程处于准备状态，等待被调度执行。线程一旦进入准备状态就再也不可能回到新建状态。

3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
一旦处于准备状态的线程获取了CPU时间，就进入运行状态，在运行状态下，线程随时可能被调度程序调度到准备状态，线程在执行时，由于需要等待某些必要条件可能会进入等待阻塞状态。

同时又几个线程能处于运行状态取决于硬件，如果是双核（每核心一线程）CPU，同一时刻可能有两个线程处于运行状态。

4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。

5、死亡态：当线程的run()方法完成时或由于发生异常而终止执行时，就认为它死去。线程一旦死亡，就不能复生。进入死亡的线程可以被当做普通对象来使用，可以调用其方法或变量，但是不能再次启动， 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

二、线程调度
java自动调度没有逻辑约束的线程时，其执行顺序是没有保障的，但是可以通过编程调用一些调度线程的方法，来实现一定程度上对线程的调度。 
有些调度方法是有保障的，有些只是影响线程进入运行状态的概率。

对于线程的阻止，考虑一下三个方面，不考虑IO阻塞的情况：

睡眠；

等待；

1、睡眠

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)
静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到准备状态。
 
这两个方法不是与某个线程对象相关联的，其可以出现在任何位置，当执行到该方法时，让执行此方法的线程进入睡眠状态。

注意线程醒来将进入准备状态，并不能保证立即执行，因此指定的时间是线程暂停执行的最小时间。

线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

睡眠的实现：调用静态方法。

        try {
            Thread.sleep(123);
        } catch (InterruptedException e) {
            e.printStackTrace();  
        }

注意：

1、线程睡眠是帮助所有线程获得运行机会的最好方法。

2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

3、sleep()是静态方法，只能控制当前正在运行的线程。
 

 
  //定义实现Runnable接口的类
   class MyRunnable1 implements Runnable
    {
       //重写run方法，指定该线程执行的代码
       public void run()
       {
           for(int i=0;i<5;i++)
            {
               System.out.println("["+i+"] 我是线程1！！！");
                //使此线程进入睡眠状态
              try
                {
                   Thread.sleep(100);
               }
               catch(InterruptedException ie)
               {
                   ie.printStackTrace();
              }            
           }
       }
    }
    //定义另外一个实现Runnable接口的类
   class MyRunnable2 implements Runnable
    {
        //重写run方法，指定该线程执行的代码
       public void run()
        {
           for(int i=0;i<5;i++)
            {
               System.out.println("<"+i+"> 我是线程2！！！");
               //使此线程进入睡眠状态
                try
               {
                   Thread.sleep(100);
               }
               catch(InterruptedException ie)
                {
                    ie.printStackTrace();
               }            
            }
        }
    }
    public class Sample16_3
   {
      public static void main(String[] args)
       {
          //创建实现Runnable接口的类
            MyRunnable1 mr1=new MyRunnable1();
            MyRunnable2 mr2=new MyRunnable2();
           //创建线程Thread对象，并指定各自的target
            Thread t1=new Thread(mr1);
           Thread t2=new Thread(mr2);
           //启动线程t1
          t1.start();
           //使主线程进入睡眠状态
           try
           {
               Thread.sleep(5);
           }
            catch(InterruptedException ie)
            {
               ie.printStackTrace();
            }        
            //启动线程t2
           t2.start();
        }
   }

2、线程的优先级和线程让步yield()

线程总是存在优先级，优先级范围在1~10之间，值越大优先级越高。
在没有特别指定的情况下，主线程的优先级为5，对于子线程，其初始优先级与其父线程的优先级相同。

JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

当线程池中线程都具有相同的优先级，调度程序的JVM实现*选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：

        Thread t = new MyThread();
        t.setPriority(8);
        t.start();

线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。
java中的线程优先级是依赖于本地平台的，在实际运行时会将线程在java中的优先级映射到本地的某个优先级。这样，如果本地提供的优先级比10个要少，则java中的不同的优先级可能会映射成相同的本地优先级，而具有基本相同的执行概率。 

 
class MyThread1 extends Thread
    {
        public void run()
        {
            for(int i=0;i<=49;i++)
            {
                System.out.print("<xiao"+i+"> ");
            }        
    }
    }
    class MyThread2 extends Thread
    {
        public void run()
        {
            for(int i=0;i<=49;i++)
            {
                System.out.print("[大"+i+"] ");
            }    
        }
    }
    public class aa
    {
        public static void main(String[] args)
        {
            MyThread1 t1=new MyThread1();
            MyThread2 t2=new MyThread2();
            t1.setPriority(Thread.MIN_PRIORITY);
            t2.setPriority(Thread.MAX_PRIORITY);
            t1.start();
            t2.start();              
        }
    } 

 
这里并不是说高优先级的一直占用CPU，只是说高优先级的争夺的机会大，交替执行还是存在的。

3、线程的让步，暂停当前正在执行的线程对象，并执行其他线程。

线程让步包括两种方式，一：线程只是让出当前CPU的资源，具体让给谁不确定。
二：线程将给指定的线程让步，指定线程没有完成，其绝不恢复执行。

yield()方法

yield()应该做的是让当前运行线程回到准备状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到准备状态，但有可能没有效果。

class MyRunnable implements Runnable
  {
      private String flagl;
        private String flagr;
  public MyRunnable(String flagl,String flagr)
    {
          this.flagl=flagl;
            this.flagr=flagr;
       }    
    public void run()
      {
            for(int i=0;i<30;i++)
        {
              System.out.print(flagl+i+flagr);
               //调用yield方法使当前正在执行的线程让步
              Thread.yield();
          }
        }
    }
   public class Sample16_5
    {
      public static void main(String[] args)
      {
           //创建两个实现Runnable接口的类的对象
           MyRunnable mr1=new MyRunnable("[","] ");
            MyRunnable mr2=new MyRunnable("<","> ");
          //创建两个线程Thread对象，并指定执行的target
           Thread t1=new Thread(mr1);
           Thread t2=new Thread(mr2);
            //启动线程t1、t2
              t1.start();    
            t2.start();    
       }
    }
 这里线程时交替执行的，但是是没有保障的，有时交替有时无法做到。

 
join()方法 
当一个线程必须等待另一个线程执行完毕时，才恢复执行时使用join方法。是有保障的。

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。
class MyThread extends Thread
  {
      public void run()
      {
          for(int i=0;i<30;i++)
          {
              System.out.print("["+i+"] ");
           }
           System.out.print("{子线程执行结束} ");
       }
   }
   public class Sample16_6
   {
      public static void main(String[] args)
        {
         Thread t=new MyThread();
          t.start();    
           for(int i=0;i<30;i++)
           {
               if(i==10)
              {
                    //主线程中调用join方法使主线程进行让步
                   try
                   {
                      System.out.print("{使用了Jion方法} ");
                       t.join();//等待该线程终止。
                   }
                   catch(InterruptedException ie)
                   {
                       ie.printStackTrace();
                    }                
               }
              System.out.print("<"+i+"> ");
           }
        }
   }
 

另外，join()方法还有带超时限制的重载版本。 例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为准备状态。

线程加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：

小结

到目前位置，介绍了线程离开运行状态的3种方法：

1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。

2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：

1、线程的run()方法完成。

2、在对象上调用wait()方法（不是在线程上调用）。

3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。

4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。