主线程：执行主（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
*/
}
}
