Java产生线程

Java产生线程的方法：

1. 继承Thread类，覆盖其run方法；
2. 实现Runnable接口，将实现类对象作为参数传递给Thread类的构造方法。

---

方法一：继承Thread类，覆盖其run方法

1. start()方法的源代码：

API中对于该方法的介绍：

使该线程开始执行；Java 虚拟机调用该线程的run方法。

结果是两个线程并发地运行：当前线程（从调用返回给start方法）和另一个线程（执行其run方法）。

多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

2. run方法的源代码：

API中对于该方法的介绍：

如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

Thread类的子类应该覆盖run方法。

3. 总结：

（1）start()方法启动线程：

真正实现了多线程运行，无需等待run方法代码执行完毕而继续执行下面的代码。

当使用start()方法来启动一个线程，这时此线程处于就绪状态（未运行），一旦得到cpu时间片，就开始运行run()方法，run()方法运行结束，此线程随即终止。

（2）run()方法启动线程：

run()方法只是类的一个普通方法。

如果直接调用run()方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，即要等待run()方法体执行完毕后才可继续执行下面的代码。

4. 代码测试（1）：

public class MyThread extends Thread {
	public static void main(String[] args) {
		Thread a = new MyThread();
		a.start();
		System.out.println("This is main thread.");
	}
	public void run() {
		System.out.println("This is another thread.");
	}
}

输出结果：

由上可见，MyThread继承了Thread类，并覆盖了run()方法。
其运行顺序如下：

5. 代码测试（2）：

public class MyThread extends Thread {
	public static void main(String[] args) {
		Thread a = new MyThread();
		a.run();
		System.out.println("This is main thread.");
	}
	public void run() {
		System.out.println("This is another thread.");
	}
}

输出结果：

其运行顺序如下：

---

方法二：实现Runnable接口，将实现类对象作为参数传递给Thread类的构造方法

1. Runnable接口中run方法:

API中对于该方法的介绍：

使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法。

方法 run 的常规协定是，它可能执行任何所需的动作。

2. 结论:

Runnable接口中的run方法是一个抽象方法，其实现类的run方法中定义的内容就是线程执行的任务，因而实现类的run方法又称为线程体。

注意：run方法无参数，并且返回类型为void。如果一个run方法有返回值或参数，则不是线程体。

3. 代码测试：

public class MyThread implements Runnable {
	public static void main(String[] args) {
		MyThread my = new MyThread();
		Thread a = new Thread(my);
		a.start();
		System.out.println("This is main thread.");
	}
	public void run() {
		System.out.println("This is another thread.");
	}
}

输出结果：

程序说明：
（1）利用接口产生线程，线程对象调用Runnable接口实现对象的run方法。
（2）因为调用的是start方法，所以同样是一个并发执行的过程：

两种创建线程方法的比较：

1. 直接继承线程Thread类：

优点：
编写简单，可以直接操作线程。
缺点：
由于已经继承了Thread，不能再继承其他类了。

创建及启动线程：

MyThread t = new MyThread();
t.start();

2. 实现Runnable接口：

当一个类已经继承了另一个类的时候，就只能用实现Runnable接口的方式来创建线程。
使用此方法的更多原因是多个线程可共享实现类对象的资源。

创建及启动线程：

MyThread t = new MyThread();
Thread t1 = new Thread(t);
t1.start();

3. 多线程访问共享资源：

（1）使用“直接继承线程Thread类”创建进程：（无法实现资源共享！！！）

public class MyThread extends Thread {
	public int i;
	public MyThread(int i) {
		this.i = i;
	}
	public void run() {
		while(true) {
			if(i>=0) {
				System.out.println(Thread.currentThread().getName()+" "+i);
				i--;
			}
			else {
				break;
			}
		}
	}
	public static void main(String[] args) {
		MyThread t1 = new MyThread(10);
		MyThread t2 = new MyThread(5);
		t1.start();
		t2.start();
	}
}

输出结果：

（2）使用“实现Runnable接口”创建进程（可以实现资源共享）：

public class MyThread implements Runnable {
	public int i;
	public MyThread(int i) {
		this.i = i;
	}
	public void run() {
		while(true) {
			if(i>=0) {
				System.out.println(Thread.currentThread().getName()+" "+i);
				i--;
			}
			else {
				break;
			}
		}
	}
	public static void main(String[] args) {
		MyThread m = new MyThread(10);
		Thread t1 = new Thread(m);
		Thread t2 = new Thread(m);
		t1.start();
		t2.start();
	}
}

输出结果：

解释：
Thread-0和Thread-1两个线程并发调用MyThread中的run方法，这样i就成了共享变量，当一个线程对i进行自减时，另一个线程对i也在自减。