java简单 线程三种创建方式

1.

创建多线程的第一种方式:创建Thread类的子类
java.lang.Thread类 是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

实现步骤:
    1.创建一个Thread类的子类
    2.在Thread类的子类中重写Thread类的run方法,设置线程任务(开启线程要做什么?)
    3.创建Thread类的子类对象
    4.调用Thread类中的方法start方法,开启新的线程,执行run方法

/*
    创建多线程的第一种方式:创建Thread类的子类
    java.lang.Thread类 是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

    实现步骤:
        1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类的run方法,设置线程任务(开启线程要做什么?)
        3.创建Thread类的子类对象
        4.调用Thread类中的方法start方法,开启新的线程,执行run方法
 */
public class Demo01Thread{
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        mt.start();
        for (int i = 0; i <=60; i++) {
            System.out.println(i);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
//        for (int i = 0; i <20 ; i++) {
//            System.out.println("run"+i);
//
//        }
//        System.out.println(getName());
//        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName());

    }
}

2.

创建多线程的第二种方式:实现Runnable接口
java.lang.Runnable
Runnable接口应该由那些打算通过某一线程执行其他实例的类来实现,类必须定义一个称为run的无参数方法.
java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target,String name)分配新的Thread对象.

实现步骤:
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法,设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的strat方法,开启新的线程执行run方法
 实现Runnable接口创建多线程程序的好处:
    1.避免了单继承的局限性
        一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
        实现了Runnable接口,还可以继承其他的类,实现其他的接口
    2.增强了程序的扩展性,降低了程序的耦合性(解耦)
        实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
        实现类中,重写了run方法:用来设置线程任务
        创建Thread类对象,调用start方法:用来开启新线程

public class Demo01Runnable {
    public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(runnable);

        //调用Thread类中的start方法,开启新的线程执行run方法
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

package demo01.demo14.Thread;
//接口实现类
public class RunnableImpl implements Runnable {
    @Override
    //重写run方法
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

3.

/*
匿名内部类实现线程的创建

匿名:没有名字
内部类:写在其他类内部的类

匿名内部类作用:简化代码
    把子类继承父类,重写父类的方法,创建子类对象合一布完成
    把实现类实现类接口,重写接口中的方法,创建类对象合成一步完成
匿名内部类的最终产物: 子类/实现类对象,而这个类没有名字

格式:
    new 父类/接口(){
    重写父类/接口中的方法};
使用线程的匿名内部类

*/

public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类的Thread
        //new MyThread().start();
        new Thread(){
            //重写run方法,设置线程任务

            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        }.start();
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }

            }
        }
).start();

    }
}

END