线程Thread

1. 线程基础

    1.1 线程的创建方式

         1.1.1 继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        //获取线程名称
//        String name = getName();
//        System.out.println(name);

//        Thread t = Thread.currentThread();
//        String name = t.getName();
//        System.out.println(name);
        System.out.println(Thread.currentThread().getName());
    }

Test类        

public class Demo01GetThreadName {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        new MyThread().start();
        new MyThread().start();
    }

    1.1.2 实现Runnable接口

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 RunnableImpl2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("helloworld"+"--->"+i);
        }
    }
}

   

/**
 * 创建多线程的第二种方式 实现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.调用Tread类中的start方法，开启新的线程执行run方法
 *
 *       实现Runnable接口创建多线程程序的好处
 *       1.避免了单继承的局限性
 *          一个类只能继承一个类，类继承了Thread类就不能继承其他类，实现了Runnable接口，
 *          还可以继承其他的类实现其他的接口
 *       2.增强了程序的扩展性，降低了程序的耦合性(解耦)
 *          实现Runnable接口的方式，把设置线程任务和开启新县城进行了分类(解耦)
 *          实现类中，重写了run方法，用来设置线程任务
 *          创建Thread类对象，调用start方法 用来开启新线程
 */
public class Demo01Runnable {

    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        Thread t1 = new Thread(new RunnableImpl2());
        //5.调用Tread类中的start方法，开启新的线程执行run方法
        t.start();
        t1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

匿名内部类的书写

/**
 * 匿名内部类方式实现线程的创建
 *
 * 匿名：没有名字
 * 内部类：写在其他类内部的类
 *
 * 匿名内部类作用：简化代码
 *     把子类继承父类，重写父类的方法，创建子类对象合一步完成
 *     把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
 * 匿名内部类的最终产物，子类/实现类对象，而这个类没有名字
 *
 * 格式：
 * new 父类/接口(){
 *   重复父类/接口中的方法
 * };
 */

public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread  1
        //new MyThread().start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+"黑马");
                }
            }
        }.start();

        //线程的接口Runnable  2
        //RunnableImpl r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 200; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+"程序员");
                }
            }
        };
        new Thread(r).start();

        //3
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+"传智播客");
                }
            }
        }).start();
    }
}

继承Thread和实现Runnable接口的区别

    a.实现Runnable接口避免多继承局限
    b.实现Runnable()可以更好的体现共享的概念

 

 

 

 

 

 

 

永远不要停止思考...