Java 多线程学习（1）——实现多线程的两种方式Thread/Runnable

重新系统的学习一下Java多线程部分。参考书籍为《java多线程编程核心技术》。

实现多线程的方式主要有两种，一种是继承Thread类，另一种是实现Runnable接口。

首先看一下Thread类的结构

public class Thread implements Runnable

Thread类实现了Runnable接口，它们之间具有多态关系。但继承Thread类创建多线程，不支持多继承。使用实现Runnable接口的方式，能够支持多继承。

不过这两种实现多线程方式的在工作时的性质是一样的，没有本质上的区别。

继承Thread类实现多线程

线程调用的随机性

使用多线程技术，代码的运行结果与代码执行顺序或调用顺序无关

public class Main {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
System.out.println("运行结束！");
}
}
class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("MyThread");
}
}

输出：

CPU执行哪个线程具有不确定性。

public class Main {
public static void main(String[] args) {
try {
MyThread myThread = new MyThread();
myThread.setName("MyThread");
myThread.start();
for (int flag = 0; flag < 10; flag++) {
Thread.sleep((int) (Math.random() * 1000));
System.out.println("main="+Thread.currentThread().getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyThread extends Thread {
@Override
public void run() {
try {
for (int flag = 0; flag < 10; flag++) {
Thread.sleep((int) (Math.random() * 1000));
System.out.println("run=" + Thread.currentThread().getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

输出：



Thread.java类中的start()方法通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。

这个过程其实就是让系统安排一个时间来调用Thread中的run()方法，启动线程，具有异步执行的效果。

如果调用代码thread.run()，就是同步执行了，此时线程对象不交由“线程规划器”处理，而由main主线程来调用run()方法，也就是必须等run()方法中的代码执行完才会执行之后的代码。

对比如下：

public class Main {
public static void main(String[] args) {
try {
MyThread myThread = new MyThread();
myThread.setName("MyThread");
myThread.run();//修改start()方法为run()方法
for (int flag = 0; flag < 10; flag++) {
Thread.sleep((int) (Math.random() * 1000));
System.out.println("main="+Thread.currentThread().getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyThread extends Thread {
@Override
public void run() {
try {
for (int flag = 0; flag < 10; flag++) {
Thread.sleep((int) (Math.random() * 1000));
System.out.println("run=" + Thread.currentThread().getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

输出：



可以看出，代码是同步执行的。

start()方法的顺序不代表线程启动顺序

public class Main {
public static void main(String[] args) {
MyThread myThread1 = new MyThread(1);
MyThread myThread2 = new MyThread(2);
MyThread myThread3 = new MyThread(3);
MyThread myThread4 = new MyThread(4);
MyThread myThread5 = new MyThread(5);
MyThread myThread6 = new MyThread(6);
MyThread myThread7 = new MyThread(7);
MyThread myThread8 = new MyThread(8);
MyThread myThread9 = new MyThread(9);
MyThread myThread10 = new MyThread(10);
myThread1.start();
myThread2.start();
myThread3.start();
myThread4.start();
myThread5.start();
myThread6.start();
myThread7.start();
myThread8.start();
myThread9.start();
myThread10.start();
}
}
class MyThread extends Thread {
private int i;
public MyThread(int i) {
super();
this.i = i;
}
@Override
public void run() {
System.out.println(i);
}
}

输出：

实现Runnable接口

public class Main {
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
System.out.println("运行结束！");
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("运行中！");
}
}

输出：