Java多线程（一）

多线程介绍

在介绍多线程之前，应该要先了解一下线程和进程的概念。

• 进程
  进程是指正在运行的程序和程序运行时需要的系统资源。准确的说，当一个程序进入内存运行，它就变成了一个进程，并且具有一定的独立功能（这里的独立是指不同进程所占用的系统资源相对独立）。
• 线程
  线程是进程中的一个执行单元，一个进程中至少有一个线程。线程自称不能自动运行，而必须栖身在某个进程之中，由进程触发执行。属于同一进程的所有线程共享该进程的系统资源。

从微观上讲，在单CPU的计算机内部，某一时刻只能有一个线程被执行。实现多线程就是要在宏观上使多个线程同时被执行。CPU使用抢占式调度模式在多个线程间进行高速的切换，可以使系统资源特别是CPU的利用率得到提高，整个程序的执行效率也得到了提高。下面用生活中的一个例子来说明一下

一家店有10个人在排队结账，队伍排成一列，柜台上只有一个收银员。在顾客掏钱付款这一段时间，收银员是处于空闲状态的，只有等到付款成功后才能等到下一个人。如果队伍排成两列，在一列顾客掏钱付款时，收银员可以转向另外一列，为其清点商品，不停的在两边切换，这样就能加快整个队列的速度。两个队列可以看成两个线程，收银员则可以看成CPU。

多线程实现

class Person{
    Stirng name;
    public Person(String name){
        this.name = name;
    }
    void show(){
        for(int i = 1; i<=100, i++){
            System.out.println("name="+name+",i="+i);
        }
    }
}
class ThreadDemo{
    public static void main(String[] args){
        Person p1 = new Person("张三"); //主线程开始
        Person p2 = new Person("李四");
        p1.show();
        p2.show(); //主线程结束
    }
}

执行程序时，Java虚拟机会找到 main 方法开始执行，一直到 main 方法执行完，这条路径称为Java的主线程。上面的代码中主线程要执行两次 show() 方法，共计200次循环，这时程序的执行效率显然是很低的，那么如何利用多线程来解决这个问题呢？

创建线程

创建线程一个新线程一共有两种方式

1. 继承Thread类创建线程

步骤：

• 定义一个类继承Thread并重写Thread中的run()方法
• 创建子类对象（即创建一个新线程）
• 调用start()方法

代码演示：

/*
*自定义线程
*/
class MyThread extends Thread{
    @Override
    public void run(){
        for(int i = 1; i<=200; i++){
            System.out.println("自定义线程"+i);
        }
    }
}
public class Test{
    public static void main(String[] args){
        MyThread p = new MyThread(); 
        //获取开始时间
        long startTime = System.currentTimeMillis();    
        p.start();
        for(int i = 1; i<=200; i++){
            System.out.println("主线程"+i);
        }
        //获取结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
    }
}

上面的代码实现了多线程，下面就具体实现原理做几点说明：

① 要执行的内容在自定义线程类的 run() 方法中，为什么不调用 run() 方法，而是去调用了 start() 方法？

线程对象的引用调用 run() 方法仅仅是普通的方法调用，不会开启新线程；而调用 start() 方法才会开启新线程。

大致过程是：调用 start() 方法开启新线程 -> 由Java虚拟机调用 run() 方法 -> 虚拟机将 run() 方法放进新线程里 -> 最后由CPU自主选择每次执行哪个线程

② 为什么要继承 Thread 类？ 重写 run() 方法？

之前提到的主线程，它要执行的任务定义在一个类的 main() 方法中。自定义线程要执行的任务都定义在 run() 方法中，而 Thread 类的 run() 方法中的任务并不是我们所需要的，所以我们要写一个类继承来 Thread 类，并重写它的 run() 方法

③ 下面是多线程例子的内存图解

多线程内存图解

多线程程序执行时，每个执行线程都有一块属于自己的栈内存空间（即栈内存是线程私有的）。图中当执行到 p.start() 时开启一个新线程，在栈内存中开辟一个新空间，并调用重写的 run() 方法，压栈（新线程栈区）执行。

2. 实现 Runnable 接口创建线程

创建线程的另外一种方式是定义实现 Runnable 接口的类。

步骤：

• 定义类实现 Runnable 接口，并覆盖接口中的 run() 方法
• 创建 Thread 类的对象
• 将接口的子类对象作为参数传入 Thread 类的构造函数
• 调用 Thread 类的 start() 方法开启线程

代码演示：

/*
*自定义线程
*/
public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0; i<10; i++){
            System.out.println("自定义线程："+i);
        }
    }
}
class test{
    public static void main(Stirng[] args){
        Runnable run = new MyRunnable();
        Thread t = new Thread(run);
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }
    } 
}

那么继承 Thread 类和实现 Runnable 接口有什么区别呢？

实现接口，避免了继承的单继承局限性

只有创建 Thread 类的对象，才能开启线程。线程任务定义在了 Runnable 接口实现类的重写 run() 方法里。由于 Runnable 接口没有开启线程的功能，所以只有将其实现类对象作为参数传入 Thread 类的构造函数。这样，在创建线程对象时就可以明确要执行的任务。

继承 Thread 类这种方法，将线程对象和线程任务耦合在了一起，不利于程序的设计。实现接口这种方式更加符合面向对象思想，线程分为两部分：一部分是线程对象；另一部分是线程任务（即 run() 方法中的代码），实现了很大程度上的解耦。