（转）Thread 介绍(一)

引用

线程（引用自Java API doc）：
引用
线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。


线程的一些特性：
所有的Java代码都是在某个线程中执行的，所以在任一行Java代码中使用Thread.currentThread()都可以得到当前运行线程。
JVM允许多个线程并发执行，虽然同一时刻只能有一个线程占用CPU，但每个线程占有的时间片非常短，所以人类的感官上多个线程是并发执行的。
当 JVM启动时，至少有一个用户线程运行，即执行某个类的main方法的线程。


线程在下列情况之一终止运行：
Thread.run方法运行完毕(或者是Thread包含的Runnable对象的run方法执行完毕)
run方法内的代码运行时发生异常。


JVM在下列情况下终止运行：
所有非守护线程（即用户线程，非daemon线程）终止。假如有main线程和另外一个用户线程在运行，即使main线程终止了，还必须等待另外一个线程终止JVM才会终止。
调用了Runtime类的exit方法（启动虚拟机的关闭序列）。
外部程序强行终止虚拟机执行（非正常退出）。


创建线程：

继承Thread类，覆盖run方法
实现Runnable接口，通过Thread类的带Runnable参数的构造函数传入到Thread对象内,一种常用的方式：
Java代码 
Thread t=new Thread(new Runable(){ 
  public void run(){ 
     //do something 
  }  
}); 


运行线程：
调用Thread的start方法，调用之后，JVM启动一个新的线程，在新线程中执行该线程对象的run方法。
线程启动之后，不能再调用start方法，否则会抛出IllegalThreadStateException

线程的一些自动继承的特性：
如果未指明优先级，则被创建的线程和创建它的线程具有相同优先级。
如果未指明ThreadGroup，则被创建的线程和创建它的线程使用相同的ThreadGroup。如果指定ThreadGroup为null,则系统会自动将本线程加入系统级的ThreadGroup。所以说不存在没有ThreadGroup的线程。
如果未指明是否守护线程，则被创建的线程和创建它的线程具有相同的daemon属性。也就是说守护线程创建的线程如果未特别指定，则是守护线程，用户线程创建的线程如果未特别指定，则是用户线程。main线程是用户线程，除非被Thread.currentThread().setDaemon(true)方式改变。(根据oxromantic的指正，此处是错误的，正在运行的线程如果调用setDaemon会抛出java.lang.IllegalThreadStateException异常，main线程肯定是正在运行的，setDaemon只有在start()方法之前调用才有效。感谢oxromantic指正)
守护线程和用户线程：

当最后一个用户线程终止的时候，所有守护线程将被“终止”（不是被interrupt）,虚拟机退出。即使守护线程是个死循环。以下代码放入main方法里：
Java代码 
//请等待足够久的时间(可能是1-2分钟)，程序会自动停止。 
Thread t1=new Thread(){ 
public void run(){ 
  int i=0; 
  while(true){//死循环 
   i++; 
   System.out.println(i); 
   //Thread.yield();//如果想让t2有机会更快完成，需要调用yield让出CPU时间。 
  } 
} 
}; 
t1.setDaemon(true);//注释掉这句就可以看出区别了。 
Thread t2=new Thread(){ 
public void run(){ 
  int i=50000; 
  while(i>0){ 
   i--; 
  } 
  System.out.println("t2 done"); 
} 
}; 
t1.start(); 
t2.start(); 


线程优先级：
线程优先级范围是1-10，1最低优先级10最高优先级。
优先级越高越先被JVM从“等待运行”（waiting-to-run）的状态挑选出来运行。
JVM线程和操作系统线程的关系有2种（甚至可能是3种,依赖于平台和JVM实现）：


n-1关系，所有JVM线程都在同一个OS线程中运行。

n-m关系，一个JVM线程是可以在多个OS线程中运行，一个OS线程可运行多个JVM线程，不管硬件是多核还是单核。

1-1关系，一个JVM线程对应一条OS进程。（早期JVM的在Linux上的实现版本）


所以，线程的优先级设置是不可靠的，依赖于JVM实现和OS。.NET线程5个等级:Highest,AboveNormal,Normal,BelowNormal,Lowest.Solaris有15个等级，最高的5个等级是给进程中断层级（Process Interrupt Levels ，PILs）使用。也就是说PIL可以中断普通进程知道执行直到其运行结束。剩下的10个优先级可以被线程使用。所以优先级8和9可能并没有区别。默认优先级是5，最大优先级由所在ThreadGroup的maxPriority决定。也就是说所属ThreadGroup最大优先级是8则，以构造函数Thread(ThreadGroup g,String name)所创建的线程即使将其设置为10，优先级仍然是8.
当等待运行的线程中有3种优先级相差比较大的线程在运行的时候，单任务操作系统会按高-中-低的顺序来执行线程，也就是说先跑完所有高等级的再跑低等级的，多任务操作系统则会间歇执行，但不保证高优先级的、相同任务内容的任务会更快完成，即使你让线程跑上10分钟。非常诡异，可能跟CPU是双核有关（但用3个优先级且混合启动线程还是有可能高优先级的跑输给低优先级的，哪怕是最高10和最低1）。
给出代码，请读者分别在Linux和Windows下测试，有条件的话在Solaris上也试试。给个报告出来。
Java代码 
    public static void main(String[] args) throws Exception { 
        int x=211;//210个线程分3组，每组70个，第211是“发令枪” 
        int n=0;//a类线程数量，本类线程优先级最高 
        int m=0;//b类线程数量，本类线程优先级最低 
        int l=0;//c类线程数量，本类线程优先级中间（5） 
         
        final CyclicBarrier cb=new CyclicBarrier(x);//发令枪类，让所有线程理论上在同一起跑线（也许和逐个逐个start没区别） 
        final List ln=new ArrayList(7);//存放a类线程的列表，为了在匿名类中可见，定义为final,7原本是21个线程在跑，后来为了理论上消除误差，增加到70个，此处没有修改过来。 
        final List lm=new ArrayList(7);//存放b类线程的列表 
        final List ll=new ArrayList(7);//存放c类线程的列表 
        for(int i=0;i<x-1;i++){//为了避免线程在创建的时候同类线程扎堆（理论上可能）产生误差，打乱创建过程。为了避免2组线程分别在双核CPU上各自单核上运行，采用了3组线程。 
            Runner t=null; 
            if(i%3==0){ 
                t=new Runner(cb,"a"+i); 
                t.setPriority(8);//可以用10，但测试结果看不出区别。 
                ln.add(t); 
                n++; 
            }else if(i%3==1){ 
                t=new Runner(cb,"b"+i); 
                t.setPriority(2);//可以用1， 
                lm.add(t); 
                m++; 
            }else{ 
                t=new Runner(cb,"c"+i); 
                t.setPriority(5); 
                ll.add(t); 
                l++; 
            } 
            t.start();//不是真的启动线程哦。请看Runner类 
        } 
        System.out.println(n);//检验是不是每组70个。 
        System.out.println(m); 
        System.out.println(l); 
         
        try { 
            Thread.sleep(3000);//本意是为了让Runner在起跑线都预备好，在此停3秒。减少误差。 
            Timer timer =new Timer(true);//定时打印结果的线程。 
            timer.scheduleAtFixedRate(new TimerTask(){ 
 
                @Override 
                public void run() {//定时打印每组线程的结果的平均值，由于打印是有先后顺序的，所以使用平均值，消除时间差（用心良苦啊。。。） 
                    System.out.println("a avg--"+getAvg(ln));//可以将a组的结果放在最后，结果通常还是a最慢 
                    System.out.println("b avg--"+getAvg(lm)); 
                    System.out.println("c avg--"+getAvg(ll)); 
                } 
                 
                 
            }, 3000, 3000);//3秒打印一次。 
            cb.await();//发令枪响。 
        } catch (InterruptedException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } catch (BrokenBarrierException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
        System.out.println("started "); 
         
         
    } 
     
     
    public static BigInteger getAvg(List l){//为什么用大整数？因为long,和int我都试过得不到想要的结果。 
        BigInteger total=BigInteger.valueOf(0); 
        for (Iterator iter = l.iterator(); iter.hasNext();) { 
            Runner r = (Runner) iter.next(); 
            total=total.add(r.getCountPerMs()); 
        } 
        return total.divide(BigInteger.valueOf(l.size()));//同组线程的结果的平均值 
    } 
     
    static class Runner extends Thread{//有心人可以试试改成只实现Runnable接口 
        private CyclicBarrier cb; 
        private String name; 
        private BigInteger count=BigInteger.valueOf(0); 
        private long startTime; 
        public Runner(CyclicBarrier cb,String name){ 
            this.cb=cb; 
            this.name=name; 
        } 
        public void run(){ 
            try { 
                cb.await();//让其在起跑线上等待其他线程和发令枪声 
                System.out.println(this.name+"start");//看看各个线程真正跑起来是否一致，不怕，每组有70条，一条拖后退问题不大，只要运行时间够长，体力好的应该还是不会输在起跑线的。 
                 
                startTime=System.currentTimeMillis();//原本是为了消除时间差使用的，效果不好，改用发令枪，留着成了僵尸代码 
                for (;;) { 
                    count=count.add(BigInteger.valueOf(1)); 
                    Thread.sleep(1);//调试手段，为了使线程慢跑，可以去掉对比结果。 
//                  if(count%10000==0){ 
//                      Thread.yield();//调试手段，效果不明显，也毙掉了。 
//                  } 
//                  if(count.mod(m)==0){ 
//                      String info = name+":"+(count/100000)+"--"+this.getPriority()+"-"+this.isDaemon(); 
////                        System.out.println(info);//早期调试手段，毙掉。 
//                  } 
                } 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } catch (BrokenBarrierException e) { 
                e.printStackTrace(); 
            } 
              
        } 
        public BigInteger getCountPerMs(){ 
//          long value=System.currentTimeMillis()-startTime; 
////            System.out.println(value); 
////            System.out.println("count "+this.count); 
//          if(value==0)return BigInteger.valueOf(0); 
//          return this.count.divide(BigInteger.valueOf(value)); 
//以上一大段注释掉的代码原本是为了消除时间差的。没啥效果，毙掉 
            return this.count; 
        } 
    } 

结果大大出乎意料，通常a跑得最慢，b跑得最快.......
理论估计：会不会是a优先级高切换太频繁，切换的开销大过运行的开销？？,猜测，高手可以指点一下。
结论：不要依赖线程之间的竞争来得到想要的结果。