java 镶嵌创建线程_java 创建线程

一.继承Thread类

为创建一个线程，最简单的方法就是从Thread类继承。这个类包含了创建和运行线程所需的一切东西。Thread类最重要的方法是run()，但为了使用run()，必须对其进行重写。因此，run()属于那些会与程序中的其他线程“并发”或“同时”执行的代码。下面的例子是继承Thread类的一个简单实现。

java程序如下：

public class SimpleThread extends Thread {

private int countDown = 5;

private int threadNumber;

private static int threadCount = 0;

/**

* 为每个线程分配一个编号

*/

public SimpleThread() {

threadNumber = ++threadCount;

System.out.println("Making Thread" + threadNumber);

}

/**

* 从5到1进行计数

*/

@Override

public void run() {

while (true) {

System.out.println("Thread" + threadNumber + "：" + countDown);

if (--countDown == 0) {

return;

}

}

}

public static void main(String[] args) {

for (int i = 0; i < 5; i++) {

new SimpleThread().start();

}

}

}

执行结果如下：

Making Thread1

Making Thread2

Making Thread3

Making Thread4

Making Thread5

Thread3：5

Thread3：4

Thread3：3

Thread3：2

Thread1：5

Thread3：1

Thread1：4

Thread1：3

Thread1：2

Thread1：1

Thread4：5

Thread4：4

Thread4：3

Thread4：2

Thread5：5

Thread5：4

Thread5：3

Thread5：2

Thread5：1

Thread2：5

Thread2：4

Thread2：3

Thread2：2

Thread2：1

Thread4：1

在main()方法中，可看到创建并运行了大量线程。Thread包含了一个特殊的方法叫做start()，它的作用是对线程进行特殊的初始化，然后调用run()。如果不调用start()，线程便永远不会启动。

二.实现Runnable接口

在实际开发中，一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。示例如下：

java代码如下：

public class SimpleThread implements Runnable {

private int countDown = 10;

/**

* 从10到1进行计数

*/

@Override

public void run() {

while (true) {

synchronized(this) {

if (countDown > 0) {

System.out.println(Thread.currentThread().getName() + "：" + countDown--);

} else {

return;

}

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public static void main(String[] args) {

SimpleThread sd = new SimpleThread();

for (int i = 0; i < 3; i++) {

new Thread(sd).start();

}

}

}

执行结果如下：

Thread-0：10

Thread-2：9

Thread-2：8

Thread-1：7

Thread-2：6

Thread-2：5

Thread-2：4

Thread-2：3

Thread-2：2

Thread-2：1

两种实现方式的区别和联系：

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

避免点继承的局限，一个类可以继承多个接口。

适合于资源的共享