创建新执行线程有两种方法。
一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。
例如,计算大于某一规定值的质数的线程可以写成:
class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
. . .
}
}
然后,下列代码会创建并启动一个线程:
PrimeThread p = new PrimeThread(143);
p.start();
1,继承Thread
定义类继承Thread
重写run方法
把新线程要做的事写到run方法中
创建线程对象
开启新线程,内部会自动执行run方法
具体的多线程实现代码如下:
package com.yy.thread;
public class Demo2_Thread {
/**
* 创建新执行线程有两种方法。
* 一种方法是
* ①将类声明为 Thread 的子类。
* ②该子类应重写 Thread 类的 run 方法。
* ③接下来可以分配并启动该子类的实例。
* */
public static void main(String[] args) {
//开启一条线程
Mythread mt = new Mythread(); //4,创建线程(Thread类)的子类对象
mt.start(); //5,开启线程,需要一定的时间,所以说,JVM会先执行for循环语句,也就是,会先输出bb,之后再输出aaaaaaa;然后再相互交替输出
//public void start() : 使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
// mt.run(); //如果这样调用,只是调用了run方法,执行run方法里面的for循环,线程还是主线程这一个线程,不会出现交替的多线程形式
//主线程
for (int i = 0; i < 100; i++) { //为了便于观察多线程的执行,在主方法里面进行for循环
System.out.println("bb"); //这个for循环就是主线程的,两条线程开启多线程便于观察
}
//两条线程相互交替进行,即多线程实现
}
}
class Mythread extends Thread{ //1,继承Thread
public void run(){ //2,重写run方法
for (int i = 0; i < 100; i++) { //3,将要执行的代码写到run方法中
System.out.println("aaaaaaa");
}
}
}
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。
然后可以分配该类的实例,在创建 Thread 时作为一个参数来传递并启动。
采用这种风格的同一个例子如下所示:
class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
}
public void run() {
// compute primes larger than minPrime
. . .
}
}
然后,下列代码会创建并启动一个线程:
每个线程都有一个标识名,多个线程可以同名。如果线程创建时没有指定标识名,就会为其生成一个新名称。
PrimeRun p = new PrimeRun(143);
new Thread(p).start();
2,实现Runnable
定义类实现Runnable接口
实现run方法
把新线程要做的事先到run方法中
创建自定义的Runnable子类对象
创建Tread对象,传入Runnable
调用start()开启新线程,内部会自动调用Runnable的run()方法
具体的多线程实现代码如下:
package com.yy.thread;
public class Demo3_Thread {
/**
* 创建线程的另一种方法是
* ①声明实现 Runnable 接口的类。
* ②该类然后实现 run 方法。
* ③然后可以分配该类的实例,在创建 Thread 时作为一个参数来传递并启动。
*
* Runnable里面只有一个run()方法,实现Runnable只需要重写run()方法即可
*
*
* 实现Runnable的原理
* 查看源码:
* 1,看Thread类的构造函数,传递了Runnable接口的引用
* 2,通过init()方法找到传递的target给成员变量的target赋值
* 3,查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法
* */
public static void main(String[] args) {
MyRunnable wsq = new MyRunnable(); //4,创建Runnable的子类对象
// Runnable target = wsq; //父类引用指向子类对象,new MyRunnable()这个是子类对象也就是wsq
Thread yy = new Thread(wsq); //5,将其当作参数传递给Thread的构造函数; wsq代表Runnable的子类对象
yy.start(); //6,开启线程; Thread里面才有start()方法
// new Thread(wsq).start(); //这种方法与上面的两行代码实现的做用一样
for (int i = 0; i < 100; i++) {
System.out.println("你,陪我步入蝉夏,越过城市喧嚣,歌声还在游走,你榴花般的笑容");
}
}
}
class MyRunnable implements Runnable { //1,定义一个类,实现Runnable方法
@Override
public void run() { //2,重写run方法
for (int i = 0; i < 100; i++) { //3,将要执行的代码写到run方法中
System.out.println("我真的好想你,在每一个雨季。");
}
}
}
两种方法的区别:
- a.继承Thread : 由于子类重写了Thread类的run(),当调用start()时,直接找子类的run()方法
- b.实现Runnable : 构造函数中传入了Runnable的引用,成员变量记住了它,start()调用run()方法时内部判断成员变量Runnable的引用是否为空,不为空,编译时看的是Runnable的run(),运行时执行的时子类的run()方法
继承Thread(开发中优先考虑)
好处:可以直接使用Thread类中的方法,代码简单
弊端:如果已经有了父类,就不能有这个方法,因为java是单继承的
实现Runnable接口(实际上是对继承Thread的补充)
好处:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,接口是可以多实现的,拓展性强
弊端:不能直接使用Thread中的方法,需要先获取到线程对象后,才能得到Thread的方法,代码复杂