Java 多线程的创建

Java元的JVM允许程序运行多个线程，使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类

线程的创建方式有两种，一者为继承Thread类，一者为实现Runnable接口

实现方式之一：继承Thread类

实现步骤

Java通过继承Thread类来创建并启动多线程的步骤如下：

• 创建一个继承于Thread类
• 重写Thread类的run() 将此线程要执行的操作，生命在此方法体中
• 创建当前Thread 的子类的对象
• 通过对象调用start() —>1. 启动线程 2.调用当前线程的run()方法

创建一个分线程1，用于遍历100日内的偶数

class PrintNumber extends Thread{@Override重写Thread类中的run()方法  ---->将此线程要执行的操作，声明在方法体中public void run() {for(int i=0;i<=100;i++){if(i % 2 == 0){System.out.println(i);}}}
}public class NumberTest{public static void main(String []args){//创建当前Thread的子类的对象PrintNumber t1 = new PrintNumber();//通过对象调用start()方法   start是父类Thread中的方法t1.start();}
}//API中start()的描述
//Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
//启动线程，JVM会调用当前线程的run()方法

分线程会和main()并发进行,改动后

public class ThreadTest {public static void main(String[] args) {OneThread o1 = new OneThread();o1.start();for(int i = 0; i< 1000000; i++){System.out.println("这是main方法");}}
}class OneThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 1000000; i++) {System.out.println("这是OneThread");}}
}
//当运行此程序时，输出为
//这是main方法 与 这是OneThread 交叉输出 
//也可以使用Thread.currentThread().getName()直观的输出 该线程的名称

深入思考

问题一

run()方法已经重写，并且run()方法中是分线程所需要执行的操作，那能否使用run()方法替换start()方法的调用，实现分线程的创建和调用?

不能，如果这样使用，则不会创建多线程，就相当于一个普通的方法

示例

public class ThreadTest {public static void main(String[] args) {OneThread o1 = new OneThread();o1.start();for(int i = 0; i< 1000000; i++){System.out.println(Thread.currentThread().getName());}}
}class OneThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 1000000; i++) {System.out.println(Thread.currentThread().getName());}}
}//输出结果（节选）
Thread-0
Thread-0
Thread-0
main
main
main
main

更改之后

public class ThreadTest {public static void main(String[] args) {OneThread o1 = new OneThread();o1.start();for(int i = 0; i< 1000000; i++){System.out.println(Thread.currentThread().getName());}}
}class OneThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 1000000; i++) {System.out.println(Thread.currentThread().getName());}}
}
//输出结果（节选）
main
main
main
//此时，全是main方法中的线程，相当于调用了一个普通类的普通方法，并不是多线程

问题二

能否在提供一个线程，用于输出偶数？

class PrintNumber{public void run(){for(int i = 0; i< 100 ;i++){if(i % 2 == 0){System.out.println(i);}}}
}public class NumberTest{public static void main(String []args){PrintNumber p1 = new PrintNumber();p1.start();p1.start();}
}
//输出结果
0 - 100的 偶数（省略）
Exception in thread "main" java.lang.IllegalThreadStateExceptionat java.base/java.lang.Thread.start(Thread.java:1525)at 多线程.EvenNUmberTest.main(EvenNUmberTest.java:9)

不能让已经start()的线程再次执行star()方法，否则报异常。非法的线程状态。

若想要再次提供一个线程，可以再实例化一个对象，用这个对象调用start()方法

问题三

创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数

public class NumberTest {public static void main(String[] args) {EvenNumberPrint t1 = new EvenNumberPrint();OddNumberPrint t2 = new OddNumberPrint();t1.start();t2.start();}
}class EvenNumberPrint extends Thread{   //用于打印偶数@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if(i % 2 == 0){System.out.println(Thread.currentThread().getName()+" "+i);}}}
}
class OddNumberPrint extends Thread{    //用于打印奇数@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if(i % 2 != 0){System.out.println(Thread.currentThread().getName()+" "+ i);}}}
}

实现方式之一 :实现Runnable接口

实现步骤

以下为实现Runnable接口的具体步骤

• 创建一个实现Runnable接口的类
• 实现接口中的run()方法 ——> 将此线程要执行的操作，声明在run()方法体中
• 创建当前实现类的对象
• 将此对象作为参数传递到Thread类中的构造器中，创建Thread类的实例
• Thread类的实例调用start（）方法。start的作用 ①启动线程②调用run（）方法

普通方式

public class EvenNumberTest {public static void main(String[] args) {//创建当前类的实例化EvenNumberPrint p = new EvenNumberPrint();//将此对象作为参数传递到Thread类的构造器中Thread t1 = new Thread(p);t1.start();}
}class EvenNumberPrint implements Runnable{@Overridepublic void run() {for (int i = 0; i <= 100; i++) {System.out.println(Thread.currentThread().getName() +" "+ i);}}
}//输出结果
//
Thread-0 0
Thread-0 1.....省略
Thread-0 100

使用接口匿名实现类的匿名对象

//使用实现Runnable接口的方式，提供了Runnable接口匿名实现类的匿名对象
public class EvenNumberTest {public static void main(String[] args) {new Thread(new Runnable(){public void run(){for(int i = 0; i < 100 ; i++){System.out.println(Thread.currentThread().getName() + i);}}}).start();}
}

两种实现方式的对比

共同点

• 启动线程时，使用的都是Thread类中定义的start()
• 创建的线程对象，都是Thread类或其子类的实例

不同点

一个是类的继承，一个是接口的实现

建议

建议使用实现Runnable接口的实现。

• 可以避免类的单继承的局限性
• 更适合处理有共享数据的问题
• 实现了代码和数据的分离

两种方式的联系

查看Thread的源码会发现，Thread类 也是实现了Ruunable接口

public class Thread implements Runnable {    }