论线程Thread与Runnable

初学java，渐对其线程机制感兴趣。

java有两种多线程机制。Thread类与Runnable类。

1. 学习Thread类创建线程
2. 学习Runnable接口创建线程
3. 两者的区别

 

Thread类

 Thread类在java.lang包中定义，我们使用它只需要新建一个类继承它，同时把类下的run()方法重写（覆盖）一遍即可。

以下是最简单使用Thread类将创建线程的方法：

public class Text_Thread extends Thread{

	//重写run()方法
	public void run() {
		for(int i = 0;i <= 5;i++) {
			System.out.println("Szymou：" + i);
		}
	}
	
	public static void main(String[] args) {
		//建立线程对象
		Thread aThread = new Text_Thread();
		Thread bThread = new Text_Thread();
		
		//对象执行
		aThread.start();
		bThread.start();
	}

}

上面结果很难看出线程在切换执行对吧？我们重写一下：

public class Text_Thread extends Thread{

	private String a;
	//重新构造Text_Thread
	public Text_Thread(String a) {
		this.a = a;//this.a为此类的a
	}
	
	//重写run()方法
	public void run() {
		for(int i = 0;i <= 5;i++) {
			System.out.println("线程"+this.a+"：" + i);
		}
	}
	
	
	public static void main(String[] args) {
		//建立线程对象
		Thread aThread = new Text_Thread("Szymou1");
		Thread bThread = new Text_Thread("Szymou2");
		
		//对象执行
		aThread.start();
		bThread.start();
	}

}

这样就可以明显看出两个线程在交互执行了。

 

Runnable接口

我们比较常用Runnable接口来创建线程。

以下为使用Runnable接口创建线程方法：

public class Text_Runnable implements Runnable{

	private String a;
	//重新构造Text_Runnable
	public Text_Runnable(String a) {
		this.a = a;//this.a为此类的a
	}
	//重写run()
	public void run() {
		for(int i = 0;i <= 5;i++) {
			System.out.println("线程"+this.a+"：" + i);
		}
	}
	
	public static void main(String[] args) {
		//创建Runnable接口对象
		Text_Runnable aThread = new Text_Runnable("Szymou1");		
		Text_Runnable bThread = new Text_Runnable("Szymou2");
		
		//由于Runnable定义下的子类中的没有start()方法，所以我们要依靠Thread的类来执行它。
		Thread aThread1 = new Thread(aThread);
		Thread bThread1 = new Thread(bThread);
		
		aThread1.start();
		bThread1.start();
	}

因为Runnable类中没有start()方法，所以需要依靠Thread下的start来执行。因为在Thread类下有一个构造方法是：public Thread(Thread target)；这个方法可以执行Runnable的实例，所以Thread类是可以启动Runnable的，也就是可以用其start()来协调系统资源给Runnable。

 

Thread与Runnable的区别

从以上执行结果来看，好像没什么区别。

其实是有区别的，Thread类创建的线程是不可以共享目标的资源，而Runnable接口创建的是可以共享目标对象的资源。比如，旷课问题：

以下注意目标对象的“kuangke”变量的使用情况

Thread:

public class Text_Thread extends Thread{

	private String a;
	private int kuangke = 5;
	//重新构造Text_Thread
	public Text_Thread(String a) {
		this.a = a;//this.a为此类的a
	}
	
	//重写run()方法
	public void run() {
		for(int i = 0;i <= 5;i++) {
			if(kuangke > 0) {
				System.out.println("宇某"+this.a+"：" + (kuangke--) + "节");
			}
		}
	}
	
	
	public static void main(String[] args) {
		//建立线程对象
		Thread a = new Text_Thread("旷课");
		Thread b = new Text_Thread("旷课");
		Thread c = new Text_Thread("旷课");
		
		//线程对象执行
		a.start();
		b.start();	
		c.start();
		
	}

}

Runnable:

public class Text_Runnable implements Runnable{

	private String a;
	private int kuangke = 5;
	//重新构造Text_Runnable
	public Text_Runnable(String a) {
		this.a = a;//this.a为此类的a
	}
	//重写run()
	public void run() {
		for(int i = 0;i <= 5;i++) {
			if(kuangke > 0) {
				System.out.println("宇某"+this.a+"：" + (kuangke--) + "节");
			}
		}
	}

	public static void main(String[] args) {
		//创建Runnable接口对象
		Text_Runnable aThread = new Text_Runnable("旷课");	
		
		//由于Runnable定义下的子类中的没有start()方法，所以我们要依靠Thread的类来执行它。
		Thread a = new Thread(aThread);
		Thread b = new Thread(aThread);
		Thread c = new Thread(aThread);
		a.start();
		b.start();
		c.start();
	}
	
}

由上面两个结果可知，Thread类的线程无法对其目标对象的资源共享，而是分开调用；Runnable创建的线程在使用同一目标对象时，目标对象的成员变量可以被这些线程共享。