1.在java中执行多线程编辑

在java标准库中，给我们提供了一个标准的Thread类，来操作线程。Thread 类也可以视为是 Java 标准库提供的 API（API：Thread 类提供的方法和类）。当我们创建好Thread对象，其实和操作系统中的线程是相对应的。即如果我们想要先创建一个线程，就要先创建一个Thread类的对象。

1.1通过Thread类创建线程

首先我们先创建子类，让其继承Thread,并且重写run方法

我们这里的创建线程都是在同一个进程内部实现的。另外我们为了更清楚的表示线程的并发执行，再来举其他的例子：

1.2创建线程方法2

即创建一个类实现Runnable接口，再创建 Runnable实例，并传给Thread实例

通过 Runnable 来描述任务的内容
进一步的再把描述好的任务交给 Thread 实例

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello Thread");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        //这里我们实例化的是Thread本身
        //构造方法里面指定了Runnable实例
        Thread t = new Thread(new MyRunnable());
            t.start();

    }
}

1.3创建线程方法3

public class TestDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello Thread");
            }
        };
        t.start();
    }
}

这里使用了匿名内部类，同时重写run方法和new了个匿名内部类的实例

1.4创建线程方法4

public class TestDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        });
        t.start();
    }
}

针对 Runnable 接口创建的匿名内部类（这个匿名内部类实现了Runnable 接口）。
同时将创建出的实例作为参数传给了 Thread 的构造方法.

小结：上述四个方法，我们认为Runnable方法更好一点，因为它能够让线程与线程之间的任务更能够解耦，即让代码之间高内聚，低耦合。即同一类功能的代码放一起，不同功能模块之间，没有关系。也就是说，Runnable只是单纯的描述了一个任务的具体内容，但要怎么执行，它并不关心。

1.5创建线程方法5

public class TestDemo5 {
    public static void main(String[] args) {
            //这是方法4的简化，其中（）表示无参数的run方法
            Thread t = new Thread(()->{
            System.out.println("hello Thread");
        });
        t.start();
    }
}

2.多线程执行效率

2.1两个变量同时自增

public class TestDemo6 {
    private static final long count = 10_0000_0000;

    public static void serial() {
        //记录自增开始的时间
        long begin = System.currentTimeMillis();
        long a = 0;
        for (int i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (int i = 0; i < count; i++) {
            b++;
        }
        //记录自增结束的时间
        long end = System.currentTimeMillis();
        System.out.println("花费时间：" + (end - begin) + "ms");
    }


    public static void concurrency() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < count; i++) {
                a++;
            }
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            long b = 0;
            long a = 0;
            for (int i = 0; i < count; i++) {
                b++;
            }
        });
        t2.start();

        t1.join();//让main线程等待t1线程执行结束

        t2.join();//让main线程等待t2线程执行结束
        long end = System.currentTimeMillis();
        System.out.println("多线程花费的时间：" + (end - begin));

    }

    public static void main(String[] args) throws InterruptedException {
        //serial();
        concurrency();
    }

}

? ? ? ?虽然这里我们使用多线程效率提高了，但这也是适合数据计算比较多的情况下。如果数据很少，我们就没必要使用多线程，因为创建多线程也是需要花费时间和空间的。因此使用多线程的时候还要看适用场景。

3.Thread常见构造方法和属性

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 方法
Thread()	创建线程对象
Thread(Runnable target)	使用 Runnable 对象创建线程对象
Thread(String name)	创建线程对象，并命名
Thread(Runnable target, String name)	使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group,Runnable target)	线程可以被用来分组管理，分好的组即为线程组，这个目前我们了解即可