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();  //新线程开启

     }

 }