Java线程创建的五种方式

一.Thread是什么

一个线程就是一个 " 执行流 ". 每个线程之间都可以按照顺序执行自己的代码 . 多个线程之间 " 同时 " 执行着多份代码.

常用方法如下：

1.为什么要有线程?

首先,并发编程成为刚需。最根本的原因就是单核CPU的算力遇到了瓶颈，需要多核CPU。而并发编程能够更充分的利用多核CPU的资源。

其次，虽然多进程也可以实现并发编程，但是线程比进程更轻量

主要体现在以下三个方面：

• 创建线程比创建进程更快.
• 销毁线程比销毁进程更快.
• 调度线程比调度进程更快.

2.进程和线程的区别 

• 进程是包含线程的. 每个进程至少有一个线程存在，即主线程。
• 进程和进程之间不共享内存空间. 同一个进程的线程之间共享同一个内存空间.
• 进程是系统分配资源的最小单位，线程是系统调度的最小单位

二.创建线程的五种方式

1.实现一个类，继承Thread

我们都知道，继承一个类之后，如果子类重写了其中的方法，那么实例化子类对象的时候，再运行的时候就会执行子类的方法。

package thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

public class ThreadDemo1 {
    //实现一个类,继承Thread
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();  //此处才是真正创建了线程,如果只是t.run(),只是执行了方法,是单线程
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

代码解读：

1.Thread t = new MyThread();  多态体现形式，编译是Thread，运行时是创建Mythread对象

2. Thread.sleep(1000); 是让当前线程休眠1000毫秒-->相当于1秒~

3. t.start();  //此处才是真正创建了线程,如果只是t.run(),只是执行了方法,是单线程

2. 实现Runnable接口，实现一个interface

package thread;
class MyRunnable implements Runnable{
    //Runnable的作用,是描述一个"要执行的任务"  子类
    @Override
    public void run() {
        System.out.println("Hello thread");
    }
}
public class ThreadDemo2 {
    //实现Runnable接口,实现一个interface
    public static void main(String[] args) {
        //描述了任务
        Runnable runnable = new MyRunnable();  //Runnable是一个接口,不能直接实例化,需要由其实现的子类实现
        //创建线程,把任务扔过去
        Thread t = new Thread(runnable);
        t.start(); // 创建线程

    }
}

代码解读：

1.MyRunnable 类实现了Runnable接口，那么实例化MyRunnable的时候，此时就初始化了其中的方法。

2.Thread t = new Thread(runnable);  把创建好的对象给Thread，此时线程就接收到了一个对象的引用。  为什么可以传runnable对象呢？ 原因是Thread类中有一个构造方法。

3.使用匿名内部类，继承Thread

package thread;

public class ThreadDemo3 {
    public static void main(String[] args) {
        //使用匿名内部类,继承Thread
        //创建了一个Thread父类的子类对象(子类没有名字),所以叫匿名内部类,里面要有具体实现
        Thread t = new Thread(){
            @Override               //2. 编译看父类,运行看子类
            public void run() {
                System.out.println("Hello");
            }
        };
        t.start();
    }
}

如果对匿名内部类不太清楚，可以看我博客里面的匿名内部类详解~~

这个实际上和方法1是一样的，只是没有创建 MyRunnable 类。

4.使用匿名内部类，实现Runnable接口

package thread;

public class ThreadDemo4 {
    public static void main(String[] args) {
        //使用匿名内部类，实现Runnable接口
        Thread t = new Thread(new Runnable() {  //thread里面有构造方法
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        t.start();
    }
}

此方法实际上和方法二是一样的~~，只不过使用匿名内部类来简化了开发效率

个人认为匿名内部类就是只关心里面的实现，这样可以提高开发效率。

5. 使用Lambda表达式

在Lambda标准格式的基础上，使用省略写法的规则为： 1. 小括号内参数的类型可以省略； 2. 如果小括号内有且仅有一个参，则小括号可以省略； 3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

那么使用Lanmbda表达式创建线程 操作如下 :

package thread;

public class ThreadDemo5 {
    public static void main(String[] args) {
        //使用lambda表达式  --->就相当于一个匿名函数
        Thread t = new Thread(()->{
            //这里面其实也有run方法,但是其实就是隐藏了,因为就只有一个方法
            System.out.println("hello");
        });
        t.start();
    }

}

6.创建线程时可以指定名字

 使用第三个方法

        Thread t = new Thread(()-> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("第一个");
            }

        },"好的");
        t.start();

此处  t   线程的名字就是 “ 好的 ”