多线程的实现方式

通过继承Thread类来实现多线程

继承Thread类需要重写run()方法，因为并不是所有的代码都要被线程执行，所以用run()方法来封装被线程执行的代码，直接调用run()方法时，相当于普通方法的调用，不会运行多线程，启动多线程需要用start()方法，然后由JVM调用此线程的run()方法。

//创建三个线程分别输出"+"、"-"、"*"
public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 2000; i++) {
            System.out.println("+");
        }
    }
}
public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 2000; i++) {
            System.out.println("-");
        }
    }
}
public class MyThread3 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 2000; i++) {
            System.out.println("*");
        }
    }
}
//分别创建三个线程实例
public class TestThread {
    public static void main(String[] args) {
        MyThread1 mt1=new MyThread1();
        MyThread2 mt2=new MyThread2();
        MyThread3 mt3=new MyThread3();
//        mt1.run();
//        mt2.run();
//        mt3.run();//分别输出"+"、"-"、"*"
        mt1.start();
        mt2.start();
        mt3.start();//交错输出"+"、"-"、"*"
    }
}

通过实现Runnable接口来实现多线程

通过创建一个实现Runnable接口的类重写run()方法，然后创建该类的对象并作为参数传递给Thread类来新建Thread对象。

1. 创建Runnable的实现类来重写run()方法
2. 创建Runnable的实现类对象
3. 新建Thread类对象，并将Runnable实现类对象作为其构造方法的参数

比起直接继承Thread来实现多线程相比，这个类还可以继承其他类

同一个Runnable实现类对象作为参数传递给多个线程（多个线程执行同样的操作）

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();//MyRunnable类可以看做给所有线程的一个资源
        /*
        1.创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        Thread(Runnable target)
        */
        //Thread t1 = new Thread(my);
        //Thread t2 = new Thread(my);
        /*
        2.Thread(Runnable target, String name)
        */
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

不同的Runnable实现类对象作为参数传递给多个线程（多个线程执行不同的操作）

创建Thread类对象的时候使用了Lambda表达式。

public class test {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int i = 0;
            while (i < 100) {
                System.out.println("+");
                i++;
            }
        }, "高铁");
        Thread t2 = new Thread(() -> {
            int i = 0;
            while (i < 100) {
                System.out.println("-");
                i++;
            }
        }, "飞机");
        t1.start();
        t2.start();
    }
}

Lambda表达式