Thread -线程的两种创建方式

package cn.learn.thread.Thread;
/*
    实现Runnable必须重写run()方法，一般推荐用Runnable实现

 */
public class RunnableImpl implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行");
    }
}

package cn.learn.thread.Thread;
/*
     继承Thread类，实现多线程
     实现步骤：
        1.创建一个Thread类的子类
        2.在Thread的子类中重写Thread类中的run方法设置线程任务
        3.创建Thread的子类对象
        4.调用Thread类中的start方法，开启新的线程，执行run方法
        结果是两个线程并发地运行，当前线程（main线程）和另外一个线程（执行其run方法）
        多次启动一个线程是非法的，特别线程结束后，不能重新启动
     java属于抢占式执行，哪个线程级别高就优先执行；同一个优先级随机选择

 */
public class ThreadExtends extends Thread {

    public ThreadExtends() {
    }

    //使用父类来创建新线程名称
    public ThreadExtends(String name) {
        super(name);
    }

    //重新run方法
    @Override
    public void run() {
        //获取线程名称
        //String name = this.getName();
        //System.out.println("线程名称："+name);

        //获取当前线程名称
        Thread thr = Thread.currentThread();
        System.out.println(thr);

        //链式编程
        //System.out.println(Thread.currentThread().getName());
    }
}

 package cn.learn.thread.Thread;
 /*
     JVM执行main方法，找OS开辟一条main方法通向cpu的路径
     这个路径叫main线程-主线程
     cpu通过该线程，路径就可以执行main方法

     Thread继承与Runnable接口实现的区别
     实现Runnable接口创建多线程的好处：
       1.避免了单继承的局限性
       2.增强了程序的扩展性，降低了耦合性(解耦)，eg：多个Runnable的实现类可以有不同的线程任务
       3.多个Thread对象，共用一个Runnable实现类对象的资源
  */

 public class MyThread {
     public static void main(String[] args) throws InterruptedException {
         //创建Thread类的子类对象，如ThreadExtends有构造方法可在其类用super(name)父类来创建线程名称
         ThreadExtends anThread = new ThreadExtends();

         //可以用anThread.setName();来设置线程名称

         //开辟新线程，用于执行run方法，如果直接使用run方法，还是单线程，由main方法来执行
         anThread.start(); //开辟新的栈空间，新线程，ThreadExtends类中run方法运行，获取线程名称Thread-0

         //再创建一个新线程，运行run()，获取线程名称Thread-1
         new ThreadExtends().start();  //Thread[Thread-1,5,main]

         //获取当前线程名称
         System.out.println(Thread.currentThread().getName());  //main

         //与上面的线程并发执行，不安全，抢占cpu，cpu有选择的权利，随机执行
         for (int i = 0; i <10 ; i++) {
             System.out.println("main"+i);
         }

         //Thread的sleep暂时以指定毫秒数停止执行线程，结束后继续执行
         //模拟秒表
         for (int i = 0; i <60 ; i++) {
             Thread.currentThread().sleep(1000);
             System.out.println(i);

         }

         //创建线程的第二种方法
         /*
         创建线程的另一种方法是声明实现 Runnable 接口的类。
         该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

         需要用Thread来接受其对象，调用start，运行run开启新线程
         */
         //
         RunnableImpl runnableThread = new RunnableImpl();
         //2，多个Thread共用一个runnableThread资源
         Thread t=new Thread(runnableThread);
         Thread t1=new Thread(runnableThread);
         //
         t.start();  //新线程开启
         t1.start();  //新线程开启

     }
 }