创建线程

Thread.currentThread()

package com.alanliu.Java8BasicCodeStuding.Java8BasciCode.Unit11_Thread.CreateThreadDemo;
/**
 * 多线程 实现：
 * 
 * 1：基于主线程获取对其的引用。 Thread t = Thread.currentThread();
 * 2：implements 实现 Runnable 接口 
 * 3：extends 继承 Thread 类的方法。
 * 
 * Thread类的方法：
 * getName()   获取线程的名称
 * getPriority() 获取线程的优先级
 * isAlive()  确定线程是否仍然在运行
 * join()  等待线程终止
 * run()  线程的入口点
 * sleep() 挂起线程一段时间
 * start()  通过调用线程的run()方法启动线程。
 * 、
 * 
 * 
 * @author develop
 *
 */
class CurrentThreadDemo  {
      public static void main(String args[]) {
        /**
         * 主线程：
         *   1：其重要2的因素：
         *      1-1：其他子线程都是从主线程产生的
         *      1-2：通常，主线程必须是最后才结束执行的线程。
         *  
         *    尽管主线程是在程序启动时自动创建的，但是可以通过Thread 对象对其进行控制。为此，
         *    必须调用currentThread()方法获取对主线程的一个引用。该方法是Thread的一个共有静态成员，它的一般形式如下：
         *    static Thread currentThread()            
         */
        Thread t = Thread.currentThread();

        System.out.println("Current thread: " + t);

        // change the name of the thread
        t.setName("My Thread");
        System.out.println("After name change: " + t);

        try {
          for(int n = 5; n > 0; n--) {
            System.out.println(n);
            Thread.sleep(1000);
          }
        } catch (InterruptedException e) {
          System.out.println("Main thread interrupted");
        }
      }
      /**
       * 运行结果：
       * Current thread: Thread[main,5,main]
            After name change: Thread[My Thread,5,main]
            5
            4
            3
            2
            1
       */
    }

---

implements Runnable 

package com.alanliu.Java8BasicCodeStuding.Java8BasciCode.Unit11_Thread.createThreadImplementsRunnable;

/**
 *     
 * @ClassName:  NewThread   
 * @Description: 创建线程
 * 多线程 实现：
 * 
 * 1：基于主线程获取对其的引用。 Thread t = Thread.currentThread();
 * 2：implements 实现 Runnable 接口 
 * 3：extends 继承 Thread 类的方法。
 * 
 * Thread类的方法：
 * getName()   获取线程的名称
 * getPriority() 获取线程的优先级
 * isAlive()  确定线程是否仍然在运行
 * join()  等待线程终止
 * run()  线程的入口点
 * sleep() 挂起线程一段时间
 * start()  通过调用线程的run()方法启动线程。
 * 、*    
 * @author: Alan_liu
 * @date:   2022年3月3日 下午9:45:14      
 * @Copyright:
 */
class NewThread implements Runnable {
     /**
      * 创建线程最简单方式是创建实现类 runnable接口的类。 runnable接口抽象类一个可以执行代码单元。
      * 可以依托任何实现类Runnable接口的对象来创建线程。为了实现runnable接口，类只需要实现run()方法，
      * 该方法声明如下：
      *   public void run();
      *   
      *   在 run() 方法内部，定义组成新线程的代码。run()方法代码可以调用其他方法，使用其他类，可以声明变量，
      *   就像main线程那样，
      *   唯一区别在于：run()方法为程序中另外一个并发线程的执行建立入口点。当run()方法返回时，这个线程将结束。
      *   在创建实现类runnable接口的类之后，可以在类中实例化Thread类型的对象。
      *   Thread类定义类几个构造函数。
      *   Thread(Runnable threadOb,String threadName)
      *   
      *    在这个构造类中，threadOb是实现类Runnable接口类的实例，这定义类从何处开始执行线程，新线程的名称由threadName指定。
      *    在创建类新线程后，只有调用线程的start()方法，线程才会运行，该方法是在Thread类中声明。
      *    在本质上，start() 方法执行对run()方法调用。
      *   
      */
      Thread t;

      NewThread() {
        // Create a new, second thread
        t = new Thread(this, "Demo Thread");
        System.out.println("Child thread: " + t);
        t.start(); // Start the thread
      }

      // This is the entry point for the second thread.
      public void run() {
        try {
          for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            Thread.sleep(500);
          }
        } catch (InterruptedException e) {
          System.out.println("Child interrupted.");
        }
        System.out.println("Exiting child thread.");
      }
    }




package com.alanliu.Java8BasicCodeStuding.Java8BasciCode.Unit11_Thread.createThreadImplementsRunnable;

/**
 * 
 * @ClassName:  ThreadDemo   
 * @Description: 调用 NewThread类进行测试线程运行情况。
 *   
 * @author: Alan_liu
 * @date:   2022年3月3日 下午10:06:13      
 * @Copyright:
 */
class ThreadDemo {
      public static void main(String args[]) {
        new NewThread(); // create a new thread

        try {
          for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(1000);
          }
        } catch (InterruptedException e) {
          System.out.println("Main thread interrupted.");
        }
        System.out.println("Main thread exiting.");
      }
      /**
       *   在 NewThread 类中的构造函数中，通过下面这条语句创建类一个新的Thread对象。
       *   t = new Thread(this, "Demo Thread");
       *   传递this 作为第一个参数，以表明希望新线程调用this对象的run()方法。接下来调用start()方法，从run()方法开始启动
       *   线程的执行。这会导致执行子线程的for循环。调用完start（）方法后，NewThread类的构造函数返回到main（）方法。
       *   恢复主线程时，会进入主线程的for循环。两个线程继续执行。在单核系统中他们会共享CPU，直到他们的循环结束。
       * 
       * Child thread: Thread[Demo Thread,5,main]
            Main Thread: 5
            Child Thread: 5
            Child Thread: 4
            Main Thread: 4
            Child Thread: 3
            Child Thread: 2
            Main Thread: 3
            Child Thread: 1
            Exiting child thread.
            Main Thread: 2
            Main Thread: 1
            Main thread exiting.

       * 
       * 
       * 
       */
    }

---

extends Thread

package com.alanliu.Java8BasicCodeStuding.Java8BasciCode.Unit11_Thread.CreateThreadExtendsThread;

/**
 * 
 * @ClassName:  NewThread   
 * @Description: 继承 Thread类方式 实现多线程
 * 多线程 实现：
 * 
 * 1：基于主线程获取对其的引用。 Thread t = Thread.currentThread();
 * 2：implements 实现 Runnable 接口 
 * 3：extends 继承 Thread 类的方法。
 * 
 * Thread类的方法：
 * getName()   获取线程的名称
 * getPriority() 获取线程的优先级
 * isAlive()  确定线程是否仍然在运行
 * join()  等待线程终止
 * run()  线程的入口点
 * sleep() 挂起线程一段时间
 * start()  通过调用线程的run()方法启动线程。   
 * @author: Alan_liu
 * @date:   2022年3月3日 下午10:19:21      
 * @Copyright:
 */
class NewThread extends Thread {
     /**
      * 
      * @Title:  NewThread   
      * @Description:      
      * @param:    
      * @throws
      */
      NewThread() {
        // Create a new, second thread
        /**
         * 该程序产生的输出和其他版本不同。子线程是通过实例化NewThread类创建的。NewThread类派生自Thread.
         * 注意：在NewThread类中对super()方法的调用，这会调用一下形势的Thread构造函数。
         *   
         *   public Thread(String name) {
         *        this(null, null, name, 0);
         *    }
         *   
         *   name 指定类线程的名称
         */
        super("Demo Thread");
        System.out.println("Child thread: " + this);
        start(); // Start the thread
      }
      
      // This is the entry point for the second thread.
      /**
       * 创建线程的第二种方式是创建一个扩展类Thread的新类，然后创建该类的实例。
       * 扩展类必须重写run()方法，run()方法是新线程的入口点。扩展类还必须调用start()方法以开始新
       * 线程的执行。
       * <p>Title: run</p>   
       * <p>Description: </p>      
       * @see java.lang.Thread#run()
       */
      public void run() {
        try {
          for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            Thread.sleep(500);
          }
        } catch (InterruptedException e) {
          System.out.println("Child interrupted.");
        }
        System.out.println("Exiting child thread.");
      }
    }



package com.alanliu.Java8BasicCodeStuding.Java8BasciCode.Unit11_Thread.CreateThreadExtendsThread;

/**
 * 
 * @ClassName:  ExtendThread   
 * @Description:TODO(描述这个类的作用)   
 * @author: Alan_liu
 * @date:   2022年3月3日 下午10:43:18      
 * @Copyright:
 */
class ExtendThread {
      public static void main(String args[]) {
        new NewThread(); // create a new thread

        try {
          for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(1000);
          }
        } catch (InterruptedException e) {
          System.out.println("Main thread interrupted.");
        }
        System.out.println("Main thread exiting.");
      }
      /**
       * 
       * 运行结果：
       * 
       * Child thread: Thread[Demo Thread,5,main]
        Main Thread: 5
        Child Thread: 5
        Child Thread: 4
        Main Thread: 4
        Child Thread: 3
        Child Thread: 2
        Main Thread: 3
        Child Thread: 1
        Exiting child thread.
        Main Thread: 2
        Main Thread: 1
        Main thread exiting.

       */
    }

---