更好的把握线程<一>:Thread (线程)介绍

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

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

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

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

创建线程：
[list]
[*]继承Thread类，覆盖run方法
[*]实现Runnable接口，通过Thread类的带Runnable参数的构造函数传入到Thread对象内,一种常用的方式：

Thread t=new Thread(new Runable(){
  public void run(){
     //do something
  } 
});

[/list]
运行线程：
[list]
[*]调用Thread的start方法，调用之后，JVM启动一个新的线程，在新线程中执行该线程对象的run方法。
[*]线程启动之后，不能再调用start方法，否则会抛出IllegalThreadStateException
[/list]
线程的一些自动继承的特性：
[list]
[*]如果未指明优先级，则被创建的线程和创建它的线程具有相同优先级。
[*]如果未指明ThreadGroup，则被创建的线程和创建它的线程使用相同的ThreadGroup。如果指定ThreadGroup为null,则系统会自动将本线程加入系统级的ThreadGroup。[color=red]所以说不存在没有ThreadGroup的线程。[/color]
[*]如果未指明是否守护线程，则被创建的线程和创建它的线程具有相同的daemon属性。也就是说守护线程创建的线程如果未特别指定，则是守护线程，用户线程创建的线程如果未特别指定，则是用户线程。[color=red]main线程是用户线程，除非被Thread.currentThread().setDaemon(true)方式改变。(根据oxromantic的指正，此处是错误的，正在运行的线程如果调用setDaemon会抛出java.lang.IllegalThreadStateException异常，main线程肯定是正在运行的，setDaemon只有在start()方法之前调用才有效。感谢oxromantic指正)[/color][/list]
守护线程和用户线程：
[list]
[*]当最后一个用户线程终止的时候，所有守护线程将被“终止”（不是被interrupt）,虚拟机退出。即使守护线程是个死循环。以下代码放入main方法里：

//请等待足够久的时间(可能是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();

[/list]
线程优先级：
[list]
[*]线程优先级范围是1-10，1最低优先级10最高优先级。
[*]优先级越高越先被JVM从“等待运行”（waiting-to-run）的状态挑选出来运行。
[*]JVM线程和操作系统线程的关系有2种（甚至可能是3种,依赖于平台和JVM实现）：
[list=1]
[*]n-1关系，所有JVM线程都在同一个OS线程中运行。
[*]n-m关系，一个JVM线程是可以在多个OS线程中运行，一个OS线程可运行多个JVM线程，不管硬件是多核还是单核。
[*]1-1关系，一个JVM线程对应一条OS进程。（早期JVM的在Linux上的实现版本）
[/list]
所以，线程的优先级设置是不可靠的，依赖于JVM实现和OS。.NET线程5个等级:Highest,AboveNormal,Normal,BelowNormal,Lowest.Solaris有15个等级，最高的5个等级是给进程中断层级（Process Interrupt Levels ，PILs）使用。也就是说PIL可以中断普通进程知道执行直到其运行结束。剩下的10个优先级可以被线程使用。所以优先级8和9可能并没有区别。[color=red]默认优先级是5，最大优先级由所在ThreadGroup的maxPriority决定。[/color]也就是说所属ThreadGroup最大优先级是8则，以构造函数Thread(ThreadGroup g,String name)所创建的线程即使将其设置为10，优先级仍然是8.
[*]当等待运行的线程中有3种优先级相差比较大的线程在运行的时候，单任务操作系统会按高-中-低的顺序来执行线程，也就是说先跑完所有高等级的再跑低等级的，多任务操作系统则会间歇执行，[color=red]但不保证高优先级的、相同任务内容的任务会更快完成，即使你让线程跑上10分钟。[/color]非常诡异，可能跟CPU是双核有关（但用3个优先级且混合启动线程还是有可能高优先级的跑输给低优先级的，哪怕是最高10和最低1）。
给出代码，请读者分别在Linux和Windows下测试，有条件的话在Solaris上也试试。给个报告出来。

	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优先级高切换太频繁，切换的开销大过运行的开销？？,猜测，高手可以指点一下。
结论：不要依赖线程之间的竞争来得到想要的结果。
[/list]
先写到这，下一节开讲线程的使用技巧和设计思想。