Java创建线程的方式及Thread线程的API

创建线程方式一：继承Thread类

        1.创建子类继承Thread类
        2.在子类中复写run方法，把线程需要执行的任务代码放在run方法中
        3.创建子类线程对象
        4.调用start方法启动线程，执行任务代码

MyThread类
/*
* 继承Thread类
* */
public class MyThread extends Thread{
    /*
    * 覆写run方法
    * */

    @Override
    public void run() {
        // run方法中，放入任务代码
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程 第"+(i + 1)+"次循环");
        }
    }
}


//测试类
public class Tests {
    public static void main(String[] args) {

        //创建子类线程对象
        MyThread myThread = new MyThread();
        //调用start方法启动线程，执行任务代码
        myThread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程 第"+(i + 1)+"次循环");
        }
    }
}

创建线程的方式二：实现接口Runnable

        1.创建实现类 实现Runnable接口
        2.在实现类种重写run方法，把线程需要执行的任务代码放入run方法中
        3.创建实现类对象
        4.创建Thread类对象，并传入Runnable接口的实现类对象
        5.调用start方法 启动线程 指定任务

//MyThread类
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 放入需要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程第"+(i+1)+"次循环");
        }
    }
}


//测试类
public class Tests {
    public static void main(String[] args) {


        // 创建实现类对象
        MyRunnable mr = new MyRunnable();

        // 创建Thread类对象，并传入Runnable接口的实现类对象
        Thread thread = new Thread(mr);
        // 调用start方法 启动线程 指定任务
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程第"+(i+1)+"次循环");
        }
    }
}

创建线程的方式三：匿名内部类

        1.创建Runnable的匿名内部类
        2.在匿名内部类种重写run方法，把线程需要执行的任务代码放入run方法中
        3.创建Thread线程对象，并传入Runnable的匿名类对象
        4.调用start方式启动线程，执行任务
注意:
        1.主线程一定会等子线程全部执行完毕才会    【结束主线程】
        2.子线程任务代码执行完毕，线程就会销毁

public class Tests {
    public static void main(String[] args) {

        // 创建Thread线程对象，传入创建Runnable的匿名内部类，并重写run方法
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 需要执行的代码
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程第"+(i+1)+"次循环");
                }
            }
        });

        // 启动
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程第"+(i+1)+"次循环");
        }
    }
}

Thread线程的API

//MyRunnable类
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }
}


//MyThread类
public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName()+"子线程 任务代码开始执行");

        // 暂停三秒
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName()+"子线程 任务代码结束执行");
    }
}


Tests_extends类
public class Tests_extends {

    public static void main(String[] args) {


        MyThread myThread = new MyThread();     //默认给线程起了一个名字 Thread-0
        myThread.start();

        MyThread myThread1 = new MyThread("线程A");
        myThread1.start();

        // 主线程 main
        System.out.println(Thread.currentThread().getName()+"开始执行");
        System.out.println(Thread.currentThread().getName()+"结束执行");


    }
}


Tests_impl类
public class Tests_impl {
    public static void main(String[] args) {
        // 创建实现类对象
        MyRunnable myRunnable = new MyRunnable();

        // 创建Thread对象
        Thread thread = new Thread(myRunnable);
        thread.start();

        Thread thread1 = new Thread(myRunnable);
        thread1.start();


        // 匿名对象

        new Thread(myRunnable,"线程A").start();
        new Thread(myRunnable,"线程B").start();
        new Thread(myRunnable,"线程C").start();
        new Thread(myRunnable,"线程D").start();
        new Thread(myRunnable,"线程E").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"开始执行");
                System.out.println(Thread.currentThread().getName()+"结束执行");
            }
        },"线程F");

    }
}