1、创建多线程两种方法
继承Thread类
- 定义子类继承Thread类
- 子类中重写Thread类中的public void run()方法
- 创建Thread子类对象，即创建了线程对象
- 调用线程对象start()方法：启动线程;调用run()方法
实现Runnable接口
- 定义类，实现Runnable接口
- 子类中实现Runnable接口中的 public void run() 方法
- 新建Runnable接口的子类对象
- 通过Thread类含参数构造器创建线程对象，将Runnable接口的子类对象作为形参传递给Thread类的构造器
- 调用Thread类对象的start()方法：启动线程;调用Runnable接口的子类对象run()方法
示例ImplementsRunnable 实现Runnable接口方式
2、方式一：Thread类
java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类
构造方法
public Thread() //分配一个新的线程对象public Thread(String name) //分配一个带指定名字的新线程对象public Thread(Runnable target) // 分配一个带有指定目标的线程对象public Thread(Runnable target,(String name) // 分配一个带有指定目标的线程对象并指定名字
常用方法
- void start() 启动这个线程；调用该线程里的run()方法
- void run() 子线程要执行的代码放入run()方法中
- static void sleep(long millis) 显式的让当前线程休眠millis毫秒
- String getName() 返回线程名
- static Thread currentThread() // 返回当前正在执行的线程对象的引用(即当前线程对象)，调用当前的线程
注意 start()方法和run()方法的区别，见下图
直接调用run方法是在main方法栈内运行，那就成了单线程，而调用start方法是开辟一个新的栈，才是多线程
实现步骤
1.创建一个Thread类的子类
2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法,开启新的线程,执行run方法
void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行
//1.创建一个Thread类的子类
public class MyThread extends Thread{
//2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
System.out.println("run:"+i);
}
}
}
public class Demo01Thread {
public static void main(String[] args) {
//3.创建Thread类的子类对象
MyThread mt = new MyThread();
//4.调用Thread类中的方法start方法,开启新的线程,执行run方法
mt.start();
for (int i = 0; i <20 ; i++) {
System.out.println("main:"+i);
}
}
}
3、方式二：Runnable接口
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
构造方法
Thread(Runnable target) 分配新的 Thread 对象。
Thread(Runnable target, String name) 分配新的 Thread 对象。
实现步骤
- 创建一个Runnable接口的实现类
- 在实现类中重写Runnable接口的run方法,设置线程任务
- 创建一个Runnable接口的实现类对象
- 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
- 调用Thread类中的start方法,开启新的线程执行run方法
好处:
1.避免了单继承的局限性
- 一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
- 实现了Runnable接口,还可以继承其他的类,实现其他的接口
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
- 实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
- 实现类中,重写了run方法:用来设置线程任务
- 创建Thread类对象,调用start方法:用来开启新线程
//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
//2.在实现类中重写Runnable接口的run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
public class Demo01Runnable {
public static void main(String[] args) {
//3.创建一个Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
//Thread t = new Thread(run);//打印线程名称
Thread t = new Thread(new RunnableImpl2());//打印HelloWorld
//5.调用Thread类中的start方法,开启新的线程执行run方法
t.start();
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
4、两种方式的区别及比较
- 区别
- 继承Thread类：线程代码放在Thread子类run()方法中
- 实现Runnable接口：线程代码放在了接口的子类run()方法中
- 实现Runnable接口方式的优点
- 避免了继承的单重继承局限性
- 多个线程可以共用同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源
- 增加程序的健壮性，实现解耦操作，代码可被多个线程共享，代码和线程独立
- 线程池只能放入实现Runable或Callable类线程，不能放入继承Thread的类
5、匿名内部类实现多线程
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字
格式:
new 父类/接口(){
重复父类/接口中的方法
};
代码示例
public class Demo01InnerClassThread {
public static void main(String[] args) {
//线程的父类是Thread
// new MyThread().start();
new Thread(){
//重写run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
}
}
}.start();
//线程的接口Runnable
//Runnable r = new RunnableImpl();//多态
Runnable r = new Runnable(){
//重写run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
}
}
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable(){
//重写run方法,设置线程任务
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+"传智播客");
}
}
}).start();
}
}
若有收获，就点个赞吧
0 人点赞
