线程的创建之Thread类
创建多线程的第一种方式:创建Thread类的子类
java.lang.Thread类是描述线程的类,我们要实现多线程程序,必须继承Thread类
实现步骤:
1.创建一个Thread类的子类
2.在Thread类中的子类中重写Thread类中的run方法,设置线程任务
3.创建Thread类的子类对象
4.调用Thread类中的start方法,开启新的线程,执行run方法
void start()使该线程开始执行,Java虚拟机调用该线程的run()方法
多次启动一个线程是非法的,特别是当线程已经结束执行,不能再重新启动。
Java程序属于抢占式调度,先执行优先级高的线程,同一个优先级,随机选择一个线程执行。
public class MyThread extends Thread {
@Override
public void run(){
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
创建一个该类的对象,调用对象的start()方法执行线程:
public class Demo01Thread {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
代码执行结果如下:
Thread-0: 0
main: 0
main: 1
main: 2
main: 3
main: 4
main: 5
Thread-0: 1
Thread-0: 2
Thread-0: 3
Thread-0: 4
Thread-0: 5
Thread-0: 6
Thread-0: 7
Thread-0: 8
Thread-0: 9
main: 6
main: 7
main: 8
main: 9
Process finished with exit code 0
获取线程的名称
获取线程的名称有两种方法:
1.使用Thread类中的方法getName()
2.先获取正在执行的线程,使用线程中的方法getName()获取线程的名称
public class Demo02GetThreadName {
public static void main(String[] args) {
MyThread1 mt1 = new MyThread1();
mt1.start(); //Thread-0
MyThread1 mt2 = new MyThread1();
mt2.start();
System.out.println(Thread.currentThread().getName());
for (int i = 0; i < 10; i++) {
System.out.println("main: " + i);
}
}
}
class MyThread1 extends Thread {
@Override
public void run() {
/* 两种方法获取线程名称
System.out.println(getName());
System.out.println(Thread.currentThread().getName()); */
for (int i = 0; i < 10; i++) {
System.out.println(getName() + ":" + i);
}
}
}
设置线程的名称
设置线程的名称:
1.用Thread类中的setName()
2.创建一个带参数的构造方法,传递线程的名称,调用父类的带参构造方法,让Thread类给线程起名字
public class SetThreadName {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2();
mt1.setName("Bob");
mt1.start();
MyThread2 mt2 = new MyThread2("John");
mt2.start();
}
}
class MyThread2 extends Thread {
public MyThread2() {
}
public MyThread2(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(getName() + " is running...");
}
}
}
线程的休眠
public class Demo03Sleep {
public static void main(String[] args) throws InterruptedException {
//模拟秒表
for (int i = 0; i < 10; i++) {
System.out.println(i);
Thread.sleep(1000); //线程休眠1000毫秒
}
}
}
线程的创建之Runnable
创建多线程程序的第二种方式:实现Runnable接口
Runnable应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run()的无参方法
java.lang.Thread的构造方法:
Thread(Runnable target)分配新的Thread对象
Thread(Runnable target, String name)分配新的Thread对象
实现步骤:
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法,设置线程任务
3.创建一个该实现类的对象
4.创建Thread类对象,构造方法中传递该对象
5.调用Thread类中的start()方法,开启线程执行run()方法
public class RunnableImpl implements Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
public class Demo04Runnable {
public static void main(String[] args) {
RunnableImpl ri = new RunnableImpl();
Thread t = new Thread(ri);
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
匿名内部类创建线程
public class Demo05AnonymousInnerClass {
public static void main(String[] args) {
//匿名内部类继承Thread类设置线程
new Thread() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}.start();
//匿名内部类实现Runnable接口,匿名Thread对象执行线程
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}).start();
}
}
lambda表达式创建线程
new Thread(() -> System.out.println("hello")).start();
实现Runnable接口创建多线程程序的好处:
- 避免了单继承
- 增强了程序的扩展性,降低了程序的耦合性(解耦)。实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离。如上例中,如果想要改变线程执行的任务,只需改写实现了Runnable的类,再将该类对象传递给Thread,而不用改变线程何时开始执行,何时结束执行。