Java线程（二）

1. 线程生命周期：

     线程的4个主要周期状态为创建线程、可执行(Runnable)、非可执行和终止(Dead)。当实例化一个Thread并执行start()之后，线程进入Runnable状态并开始执行run()方法。

     线程有优先权，由1(Thread.MIN_PRIORITY)到10(Thread.MAX_PRIORITY)，默认是5（Thread.NORM_PRIORITY）。可以使用Thread的setPriority()方法来设定线程的优先权，设定必须在1--10之间，否则会抛出IllegalArgumentException异常。

     如果想让当前的线程礼让一下其他线程，让其他线程有机会取得执行权，可以调用线程执行的yield()方法。例如：

public class SomeClass
{
	//...
	Thread thread = new Thread(
		new Runnable(){
		   public void run() {
			   //...
			   while(true) {
				   //... 
				   yield();  //暂时让出执行权
			   }
		   }
	});
	thread.start();
	//...
}

    有几种状况会让线程进入Not Runnable状态(或是blocked状态):

     (1)  调用sleep()方法

     (2)  调用wait()方法

     (3)  等待输入/输出完成

     当线程在Not Runnable状态时，表示有某些原因阻止它执行（例如等待使用者的文字输入、侦听网络连接等），线程排班器将不分配执行时间给这个线程，直到以下的几个情况让线程回到Runnable状态：

     (1) 线程调用notify()

     (2) 线程调用notifyAll()

     (3) 线程调用interrupt()

     (4) 输入/输出结束

     最后当执行的工作完成（或发生异常）而离开run()方法，则线程执行完毕，进入Dead状态。可以使用isAlive()方法判断线程是否存活。

2. 举个简单的例子，当使用Thread.sleep()使线程暂停执行进入Not Runnable状态时，可以使用interrupt()让它离开Not Runnable状态，当使用sleep()暂时进入Not Runnable状态而Interrupt()时，会丢出java.lang.InterruptedException异常对象。如下：

package ysu.hxy;

public class InterrruptDemo
{
	public static void main(String[] args) 
	{
        Thread thread = new Thread(
			new Runnable(){
			public void run()
			{
				try
				{
					//暂停99999ms
					Thread.sleep(99999);
				}
				catch(InterruptedException e)
				{
					System.out.println("I 'm interrupted!!");
				}
			}
		});

		thread.start();
		thread.interrupt();  //立即中断它
	}
}

 如果要暂停线程，但暂停的时间未知，使用sleep()并不是一个好方法。可以使用wait()，然后让别的线程用nofity()或notifyAll()来通知Not Runnable的线程回到Rannable状态。

2. 线程的加入(Join)

    当线程使用join()加入至另一个线程时，另一个线程会等待这个被加入的线程工作完毕，然后再继续它的动作。join()的意思表示将线程加入成为另一个线程的流程之一。使用范例如下：

package ysu.hxy;

public class ThreadA
{
	public static void main(String[] args) 
	{
         System.out.println("ThreadA执行");

		 Thread threadB = new Thread(
		          new Runnable(){
                     public void run(){
                        try
						 {
							System.out.println("Thread B 开始。。。");
							for(int i=0;i<5;i++)
							 {
								Thread.sleep(1000);
								System.out.println("Thread B 执行。。。");
							 }
							 System.out.println("Thread B 即将结束。。。");
						 }
						catch(InterruptedException e)
						 {
							e.printStackTrace();
						 }
					 }
		 });
		 
		 threadB.start();

		try
		{
			//将threadB加入threadA
			threadB.join();
		}
		catch(InterruptedException e)
		{
			e.printStackTrace();
		}

		System.out.println("Thread A 执行!");
	}
}

  程序启动后主线程就开始，在主线程中新建threadB,并在启动threadB后，将之加入主线程的流程之中。所以threadB必须先执行完毕，主线程都会再继续执行它原本的流程。执行结果如下：

                                           D:\hxy>java ysu.hxy.ThreadA
                                           ThreadA执行
                                           Thread B 开始。。。
                                           Thread B 执行。。。
                                           Thread B 执行。。。
                                           Thread B 执行。。。
                                           Thread B 执行。。。
                                           Thread B 执行。。。
                                           Thread B 即将结束。。。
                                           Thread A 执行!

    如果程序中threadB没有使用join()将之加入主线程的流程中，则最后一行显示"ThreadA 执行"的语句会先执行（因为threadB使用了sleep(),这让主线程有机会取得时间来执行)。

3. 为了防止加入的线程执行时间太久，为了防止无止境地等待这个线程工作完毕，可以在join()上指定时间，例如join(10000),表示加入成为流程之一的线程至多处理10S。如果时间到了，加入的线程还没处理完毕，就不理它了，当前的线程可以继续执行原本的工作流程。

4. 线程的停止：如果要停止一个线程的执行，不建议使用stop()来停止一个线程的执行，API中Thread()的Stop方法已被标记为deprecated。所以，要停止一个线程，最好自行实现。

     一个线程要进入Dead状态，就是执行完run()方法。简单地说，如果要停止一个线程的执行，就要提供一个方式让线程

可以完成run()的流程。

     如果线程的run()方法中执行的是一个重复执行的循环，可以提供一个标记flag来控制循环的执行，以便让循环有机会终止，线程可以离开run()以终止线程。如：

public class SomeClass implements Runnable 
{
	private boolean isContinue = true;
	public void terminate()
	{
		isContinue = false;
	}

	public void run()
	{
		while(isContinue){
			//...some satatements
		}
	}
}

  如果线程因为执行sleep()或者wait()而进入Not Runnable状态，而您想要停止它，可以使用interrupt(),而程序会抛出IterruptedException异常，使用线程离开run()方法。如下例所示：

package ysu.hxy;

public class SomeThread implements Runnable 
{
	public void run()
	{
		System.out.println("sleep...到not runnable状态");
		try
		{
			Thread.sleep(9999);
		}
		catch(InterruptedException e)
		{
			System.out.println(" I am Interrupted...");
		}
	}

	public static void main(String[] args)
	{
		Thread thread = new Thread(new SomeThread());
		thread.start();
		thread.interrupt();
	}
}

   如果程序因为输入/输出的装置等待而停滞（进入Not Runnable状态),基本上必须等待输入/输出的动作完成才能离开Not Runnable状态。无法使用interrupt() 来使得线程离开run()方法，您要提供替代的方法，基本上也是引发一个异常，而这个异常如何引发，要看所使用的输入/输出而定。例如使用readLine()方法在等待网络上的一个信息，此时线程进入Not Runnable直到读到一个信息。让它离开run()方法就是使用close()关闭它的流，这时会引发一个IOException异常而使得线程离开run()方法。例如：

public class Client
{
	private Socket skt;
	//...
	public void terminate()
	{
		skt.close();
	}

	public void run()
	{
	   //...

	   try
		{
		   BufferedReader buf = new BufferedReader(new InputStreamReader(skt.getInputStream()));

		   //读取客户端信息
		   //执行ReadLine()会进入not Runnable状态 
		   //直到读到客户端信息
		   while((userMessage=buf.readLine()) != null)
			{
			   //...
			}
		}
		catch(IOException e)
		{
			System.out.println("线程被终止……");
		}
	}
}

 此例只是个简单示范，实际的设计必须被您的程序功能与I/O类型而定。除了stop()之外，suspend()、resume()方法也被标示为deprecated，如果要达到与这些方法相同的功能，都必须自行实现。