Java线程的创建和执行

线程的创建之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接口创建多线程程序的好处：

1. 避免了单继承
2. 增强了程序的扩展性，降低了程序的耦合性（解耦）。实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离。如上例中，如果想要改变线程执行的任务，只需改写实现了Runnable的类，再将该类对象传递给Thread，而不用改变线程何时开始执行，何时结束执行。