java建立线程的三种方式（学习笔记）

参考书：疯狂java讲义，java程序设计基础。

1新建状态（newborn）当一个Thread类或者其子类的对象被声明或者是建立，但没有执行的这段状态称为新建状态。

2.就绪状态（runnable）就绪状态也称为可运行状态。处于新建状态的线程被启动后，将进入线程列队排队等候cpu的调度，此时具有了运行的条件，也就是就绪状态。

3.运行状态（Runing）就绪状态的线程得到cpu的调度并得到系统资源后便进入了运行状态。

处于运行状态的线程在一下状况下将让出cpu的控制权

●线程运行完毕。

●有比当前优先级更高的线程处于就绪状态。

●线程主动睡眠一段时间。

●线程正在等待某一资源。

4.阻塞状态（blocked）一个运行的线程在某些特殊的状况下将让出cpu，并暂时停止本身的执行。线程处于这种不可运行的状态称为阻塞状态。下面几种状况下可使一个线程进入阻塞状态。

●调用sleep()或者yield()方法。

●等待一个条件变量线程调用wait()方法。

●该线程与另外一个线程join()在一块儿。

一个线程被阻塞时不能进入排队队列，阻塞的缘由被消除时才能进入就绪状态。阻塞状态的线程一般须要某些事件才能唤醒，睡眠状态的线程必须阻塞一段固定时间。

5.消亡状态(dead)处于消亡状态的线程不具有继续执行的能力，致使线程消亡的缘由有两个：一是执行了run()方法的最后一条语句，二是进程中的线程被强制终止。

线程的调度与优先级：java语言支持抢占调度模型，每一个线程都被赋予一个执行的优先级。从1到10整数型。Thread类有三个优先级的静态变量MIN_PRIORITY（1）,MAX_PRIORITY（10）,NORM_PRIORITY（5）。

建立线程：

经过继承Thread类来建立线程的步骤以下。

1.定义Thread类的子类并重写该类的run方法。该run()方法体称为线程执行体。

2.建立Thread类的子类实列，即建立线程对象。

3.调用线程对象的start（）方法。

package Test;
class MyThread extends Thread
{
	private String who;
	public MyThread(String str)
	{
		who=str;
	}
	public void run()
	{
		for(int i=0;i<5;i++)
		{
			try
			{
				sleep((int)(1000*Math.random()));
			}
			catch(InterruptedException e)
			{
				
			}
			System.out.println(who+"正在运行");
		}
	}
}
public class App11_1 {
	public static void main(String[] args)
	{
		MyThread you=new MyThread("你");
		MyThread she=new MyThread("她");
		you.start();
		she.start();
		System.out.println("主方法main运行结束");
		
	}
}

主方法main运行结束
她正在运行
你正在运行
她正在运行
你正在运行
她正在运行
你正在运行
你正在运行
你正在运行
她正在运行
她正在运行
--------------------------------------------------------

实现Runnable借口建立线程：

●定义Runnable借口实现类，并重写Run方法，该Run()方法一样是线程的执行体。

●建立借口实现类的实例，并以实例做为Thread类的参数。该Thread对象才是真正的线程对象。

package Test;
class MyThread_ implements Runnable
{
	private String who;
	public MyThread_(String str)
	{
		who=str;
	}
	public void run()
	{
		for(int i=0;i<5;i++)
		{
			try
			{
				Thread.sleep((int)(Math.random()*1000));//注意sleep方法是Thread类的
			}
			catch(InterruptedException e)
			{
				
			}
			System.out.println(who+"正在运行");
		}
	}
}
public class App11_2 {
	public static void main(String[] args)
	{
		MyThread_ you=new MyThread_ ("你");
		MyThread_ she=new MyThread_("她");
		Thread a=new Thread(you);
		Thread b=new Thread(she);
		a.start();
		b.start();
		System.out.println("Main方法执行完毕");
	}

}

使用callable和Future建立线程。

建立并启动有返回值的线程步骤以下。

1.建立callable接口实现类，并实现call（）方法，该call（）方法将作线程的执行体，且该call（）方法有返回值。

2.建立Callable实现类的实列，使用FutureTask类来包装Callable对象，该FutureTask对象封装该Callable对象的call（）方法的返回值。

3.使用FutureTask对象做为Thread对象参数建立并启动线程。

4.调用FutureTask对象的get（）方法来得到子线程执行结束后的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;


public class ThirdThread implements Callable<Integer> {
//实现call()方法，实现线程执行体
	public Integer call()
	{
		int i=0;
		for( ;i<100; i++)
		{
			System.out.println(Thread.currentThread().getName()+"的循环变量i的值："+i);
			
	
		}
		return i;
	}
	public static void main(String[] args)
	{
		ThirdThread rt=new ThirdThread();
		//使用FutureTask类来包装Callable对象。
		FutureTask<Integer> task= new FutureTask<Integer>(rt);
		for(int i=0;i<100;i++)
		{
			System.out.println(Thread.currentThread().getName()+"的循环变量i的值："+i);
			if(i==20)
			{	//实际仍是以Callable来建立对象。并启动线程。
				new Thread(task,"有返回值的线程").start();
			}
			try
			{
				System.out.println("子线程的返回值："+task.get());
			}
			catch(Exception e)
			{
				
			}
		}
	}

}

---

学习笔记，若有错误欢迎指正