主线程:执行主(main)方法的线程。
JVM执行main方法,main方法会进入到栈内存,JVM会找操作系统开辟一条main方法通向CPU执行路径,CPU就可以通过这个路径来执行main方法,而这个路径叫main(主)线程。
单线程:Java程序中只有一个线程,执行从main方法开始,从上到下依次执行。
一,创建多线程的两种方式
一,创建Thread类子类
java.lang.Thread类:是描述线程的类想要实现多线程程序就必须继承Thread类。
步骤:
1,创建一个Thread类子类;
2,在Thread类子类中重写run方法,设置线程任务;
3,创建Thread类子类对象;
4,调用Thread类中的start方法,开启新线程,执行run方法。
注意:多次启动一个线程是非法的,特别是当线程已经结束执行后,不能再重新启动。
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.print("run:"+i+" ");
}
}
}
public class DemoMythread {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
for (int i = 0; i < 20; i++) {
System.out.print("main:"+i+" ");
}
}
/*run:0 main:0 run:1 main:1 run:2 main:2 run:3 main:3 run:4....*/
}
CPU执行多线程原理图:
多线程执行内存图:
线程的相关方法
获取线程名称:
1,使用Thread类中的方法getName()
String getName():返回线程名称。
2,先获取当前执行的线程,再使用线程方法getName获取线程名称
static Thread currentThread():返回当前正在执行的线程对象的引用。
设置线程名称:
1,使用Thread类中的方法setName(名字)
void setName(String name):改变线程名称。
2,创建带参构造方法,参数为线程名称,调用父类构造,将线程名称传递给父类。
暂时停止线程执行:
public static void sleep(long millis):使当前正在执行的线程以指定毫秒数暂停。
public class MyThread extends Thread {
public MyThread(){
}
public MyThread(String s){
super(s);
}
@Override
public void run() {
String name = getName();
System.out.println(name);
Thread tr = Thread.currentThread();
System.out.println(tr.getName());
}
}
public class DemoMythread {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.setName("线程1");
mt.start(); //Thread-0 | 线程1
MyThread mt2 = new MyThread();
mt2.start(); //Thread-1
MyThread mt3 = new MyThread("线程3");
mt3.start(); //线程3
System.out.println("主:"+Thread.currentThread().getName()); //主:main
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
}
二,实现Runnable接口
java.lang.Runnable接口,实现类可实现多线程,类中必须定义一个run的无参数方法。
java.lang.Thread(Runnable target):分配新的Thread对象。
步骤:
1,创建一个Runnable接口的实现类;
2,实现类中重写Runnable接口的run方法,设置线程任务;
3,创建一个Runnable接口的实现类对象;
4,创建Thread类对象,构造方法中传递Runnable接口的实现类对象;
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 DemoRunnable {
public static void main(String[] args) {
RunnableImpl rt = new RunnableImpl();
Thread t = new Thread(rt);
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
/*
main-->0
main-->1
Thread-0-->0
Thread-0-->1
Thread-0-->2
...
*/
}
}
二,实现Runnable接口创建多线程的好处
1,避免单继承的局限性。
一个类只能继承一个类,类继承了Thread类就不能继承其他类。
2,增强了程序的扩张性,降低了程序的耦合性(解耦)。
实现Runnable接口的方式:把设置线程任务和开启新线程进行了分离。
实现类中,重写了run方法:用来设置线程任务;
创建Thread类对象,调用start方法:用来开启新线程。
三,匿名内部类实现多线程
public class DemoInnerClassThread {
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("1:"+Thread.currentThread().getName()+":"+i);
}
}
}.start();
Runnable r = new Runnable(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("2:"+Thread.currentThread().getName()+":"+i);
}
}
};
new Thread(r).start();
/*
1:Thread-0:0
2:Thread-1:0
1:Thread-0:1
1:Thread-0:2
*/
}
}