多线程两种实现方式：
方式一： 继承Thread类的方式
方式二： 实现Runnable接口的方式。
方式一： 步骤：
// 1. 定义一个类，然后继承Thread
// 2. 重写里面的run方法，在run方法中定义线程要执行的任务
// 3. 在测试类中创建子类的对象。
// 4. 调用start方法，开启线程。
public class MyThread extends Thread {//1.定义一个类继承thread
public MyThread(String name) {
super(name);
}
public MyThread() {
}
@Override
public void run() {//2重写里面的run方法，定义线程要执行的任务
for (int i = 0; i < 100; i++) {
System.out.println("Hello world" + i);
Thread t=Thread.currentThread();
System.out.println(t.getName());
}
}
}
public class Demo01Thread {
public static void main(String[] args) {
System.out.println("main ....start");
MyThread md = new MyThread();//3.在测试类中创建子类的对象。
md.start(); // 4. 调用start方法，开启线程
System.out.println("main....end");
}
}
方法2：
多线程的第二种实现方式： 实现Runnable接口的方式。
步骤：
1. 定义一个类，实现Runnable接口
2. 重写里面的run方法，定义线程要执行的任务。
3. 在测试类中创建Runnable接口实现类对象
4. 再创建Thread对象，并且把Runnable接口实现类对象传递过去。
5. 调用start方法，开启这个线程。
多线程两种实现方式：
方式一： 继承Thread类的方式
方式二： 实现Runnable接口的方式。
第二种方式的好处：
1. 解决了java中类与类之间只能单继承的局限性。
2. Runnable接口中只有一个run方法，没有start，setName，sleep，getName等等等， Runnable接口
中的方法更加的纯粹，我们只需要在里面关注线程要执行的任务就可以了。更加符合设计模式中的单一职责原则。
3. 解耦
4. 可以更加方便的实现线程之间的数据共享。
*/
public class Demo01Runnable {
public static void main(String[] args) {
//创建runnable接口类的实现对象
//
Runnable r=new MyRunnableImpl();
//创建Thread类对象，并把runnable接口类的实现类对象传递过去
Thread t=new Thread(r);
t.start();//调用start方法开启这个线程
for (int i = 0; i < 100; i++) {
System.out.println("线程："+Thread.currentThread().getName()+"正在打印Hellojava"+i);
}
}
}
多线程中的方法：
/*
多线程中的方法。
Thread的构造方法
Thread(String name)： 传递一个线程的名字。
Thread的其他方法
String getName()： 用来获取线程的名字。
void setName(String name)：设置线程的名字
static Thread currentThread()：获取当前正在运行的线程对象。
static void sleep(long millis)：线程休眠，参数是休眠多少毫秒
*/
public class Demo02ThreadMethod {
public static void main(String[] args) {
//创建thread子类对象
MyThread md = new MyThread("大白");//构造方法
md.setName("小白");
//调用start开启线程
md.start();
//再创建一个新的线程并开启
// new MyThread().start();
// new MyThread().start();
//获取main线程名字并打印
//调用方法获取当前正在运行的线程对象
//这个方法是通过哪个线程调用的，获取的就是哪个线程对象。
Thread t = Thread.currentThread();//正在运行的程序
for (int i = 0; i < 100; i++) {
System.out.println("main 线程的名字是：" + t.getName());
}
}
}
/*
使用匿名内部类的方式创建多线程。
匿名内部类格式：
new 父类或者接口() {
重写父类或接口的方法;
}
匿名内部类真正创建的是子类对象。
*/
public class Demo02ThreadInner {
public static void main(String[] args) {
/* Thread t=new Thread(new MyRunnableImpl());//匿名对象传入参数
t.start();//分清楚匿名对象与匿名内部类区别
System.out.println("线程"+Thread.currentThread().getName()+"正在打印");*/
//匿名内部类作为参数传入线程
Thread t = new Thread(new MyRunnableImpl() {
@Override
public void run() {
System.out.println("线程" + Thread.currentThread().getName() + "正在打印");
}
});
t.start();
//使用runnable接口方式创建新的线程并运行
Runnable r2 = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"正在打印" +
"");
}
};
new Thread(r2).start();
//使用匿名内部类加匿名对象
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了");
}
}).start();
/*resuleL: Thread-1正在打印
Thread-2执行了
线程Thread-0正在打印*/
}
}