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());
    }
}

 1 package cn.learn.thread.Thread;
 2 /*
 3     JVM执行main方法，找OS开辟一条main方法通向cpu的路径
 4     这个路径叫main线程-主线程
 5     cpu通过该线程，路径就可以执行main方法
 6
 7     Thread继承与Runnable接口实现的区别
 8     实现Runnable接口创建多线程的好处：
 9       1.避免了单继承的局限性
10       2.增强了程序的扩展性，降低了耦合性(解耦)，eg：多个Runnable的实现类可以有不同的线程任务
11       3.多个Thread对象，共用一个Runnable实现类对象的资源
12  */
13
14 public class MyThread {
15     public static void main(String[] args) throws InterruptedException {
16         //创建Thread类的子类对象，如ThreadExtends有构造方法可在其类用super(name)父类来创建线程名称
17         ThreadExtends anThread = new ThreadExtends();
18
19         //可以用anThread.setName();来设置线程名称
20
21         //开辟新线程，用于执行run方法，如果直接使用run方法，还是单线程，由main方法来执行
22         anThread.start(); //开辟新的栈空间，新线程，ThreadExtends类中run方法运行，获取线程名称Thread-0
23
24         //再创建一个新线程，运行run()，获取线程名称Thread-1
25         new ThreadExtends().start();  //Thread[Thread-1,5,main]
26
27         //获取当前线程名称
28         System.out.println(Thread.currentThread().getName());  //main
29
30         //与上面的线程并发执行，不安全，抢占cpu，cpu有选择的权利，随机执行
31         for (int i = 0; i <10 ; i++) {
32             System.out.println("main"+i);
33         }
34
35
36         //Thread的sleep暂时以指定毫秒数停止执行线程，结束后继续执行
37         //模拟秒表
38         for (int i = 0; i <60 ; i++) {
39             Thread.currentThread().sleep(1000);
40             System.out.println(i);
41
42         }
43
44
45         //创建线程的第二种方法
46         /*
47         创建线程的另一种方法是声明实现 Runnable 接口的类。
48         该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
49
50         需要用Thread来接受其对象，调用start，运行run开启新线程
51         */
52         //1
53         RunnableImpl runnableThread = new RunnableImpl();
54         //2，多个Thread共用一个runnableThread资源
55         Thread t=new Thread(runnableThread);
56         Thread t1=new Thread(runnableThread);
57         //3
58         t.start();  //新线程开启
59         t1.start();  //新线程开启
60
61     }
62 }

原文地址：https://www.cnblogs.com/huxiaobai/p/11519673.html