多线程编程

https://www.jianshu.com/p/5ccce6a48fb2
https://www.jianshu.com/p/ab5ae289854a

线程：程序执行流的最小单元。它是进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位**。
多线程：从软件或者硬件上实现多个线程并发执行的技术。在单个程序中同时运行多个线程完成不同的工作。
在Java中，垃圾回收机制就是通过一个线程在后台实现的，这样做的好处在于：开发者通常不需要为内存管理投入太多的精力。反映到我们现实生活中，在浏览网页时，浏览器能够同时下载多张图片；实验楼的服务器能够容纳多个用户同时进行在线实验，这些都是多线程带来的好处。

 从专业的角度来看，多线程编程是为了最大限度地利用CPU资源——当处理某个线程不需要占用CPU而只需要利用IO资源时，允许其他的那些需要CPU资源的线程有机会利用CPU。这或许就是多线程编程的最终目的。当然，你也可以进一步了解为什么使用多线程。

对于多线程和线程之间的关系，你可以这样理解：一个使用了多线程技术的程序，包含了两条或两条以上并发运行的线程（Thread）。Java中的Thread类就是专门用来创建线程和操作线程的类。
1.创建线程
根据我们前面所学，我们可以自定义一个类，然后继承Thread类来使其成为一个线程类。

那么我们要把线程要做的事情放在哪里呢？在Java中，run()方法为线程指明了它要完成的任务，你可以通过下面两种方式来为线程提供run方法：

继承Thread类并重写它的run()方法，然后用这个子类来创建对象并调用start()方法。
通过定义一个类，实现Runnable接口，实现run()方法。

概括一下，启动线程的唯一的方法便是start()，而你需要把待完成的工作（功能代码）放入到run()方法中。

我们来创建两个线程试试。新建一个带有主方法的类CreateThread。

代码片段如下，我们在注释中继续讲解：

public class CreateThread {

    public static void main(String[] args)
    {
        Thread1 thread1 = new Thread1();
        //声明一个Thread1对象，这个Thread1类继承自Thread类的

        Thread thread2 = new Thread(new Thread2());
        //传递一个匿名对象作为参数

        thread1.start();
        thread2.start();
        //启动线程
    }
}

class Thread1 extends Thread
{
    public void run()
    {
        //在run()方法中放入线程要完成的工作

        //这里我们把两个线程各自的工作设置为打印100次信息
        for (int i = 0; i < 100; ++i)
        {
            System.out.println("Hello! This is " + i);
        }

        //在这个循环结束后，线程便会自动结束
    }
}

class Thread2 implements Runnable {
    //与Thread1不同，如果当一个线程已经继承了另一个类时，就建议你通过实现Runnable接口来构造

    public void run()
    {
        for (int i = 0; i < 100; ++i)
        {
            System.out.println("Thanks. There is " + i);
        }
    }
}

在控制台就可以看到下面这样的输出信息。两个线程近似交替地在输出信息。受到系统调度的影响，两个线程输出信息的先后顺序可能不同。

2.查看线程运行状态
线程的状态共有6种，分别是：新建New、运行（可运行）Runnable、阻塞Blocked、计时等待Timed Waiting、等待Waiting和终止Terminate。

当你声明一个线程对象时，线程处于新建状态，系统不会为它分配资源，它只是一个空的线程对象。

调用start()方法时，线程就成为了可运行状态，至于是否是运行状态，则要看系统的调度了。

调用了sleep()方法、调用wait()方法和IO阻塞时，线程处于等待、计时等待或阻塞状态。

当run()方法执行结束后，线程也就终止了。

我们通过一个例子来加深对于这些状态的理解。新建ThreadState类，用于自定义线程的状态。

主要的代码如下：

public class ThreadState implements Runnable {

    public synchronized void waitForAMoment() throws InterruptedException {

        wait(500); 
        //使用wait()方法使当前线程等待500毫秒
        //或者等待其他线程调用notify()或notifyAll()方法来唤醒
    }

    public synchronized void waitForever() throws InterruptedException {

        wait(); 
        //不填入时间就意味着使当前线程永久等待，
        //只能等到其他线程调用notify()或notifyAll()方法才能唤醒
    }

    public synchronized void notifyNow() throws InterruptedException {

        notify(); 
        //使用notify()方法来唤醒那些因为调用了wait()方法而进入等待状态的线程
    }

    public void run() {

        //这里用异常处理是为了防止可能的中断异常
        //如果任何线程中断了当前线程，则抛出该异常

        try {
            waitForAMoment(); 
            // 在新线程中运行waitMoment()方法

            waitForever(); 
            // 在新线程中运行waitForever()方法

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

然后再新建一个测试类ThreadTest，用于输出这些状态。

接下来会用到sleep()方法，下面给出了这个方法的使用方法。

sleep()，在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。填入的参数为休眠的时间（单位：毫秒）。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        ThreadState state = new ThreadState();
        //声明并实例化一个ThreadState对象

        Thread thread = new Thread(state);
        //利用这个名为state的ThreadState对象来创建Thread对象

        System.out.println("Create new thread: " + thread.getState());
        //使用getState()方法来获得线程的状态，并进行输出

        thread.start(); 
        //使用thread对象的start()方法来启动新的线程

        System.out.println("Start the thread: " + thread.getState());
        //输出线程的状态

        Thread.sleep(100); 
        //通过调用sleep()方法使当前这个线程休眠100毫秒，从而使新的线程运行waitForAMoment()方法

        System.out.println("Waiting for a moment (time): " + thread.getState());
        //输出线程的状态

        Thread.sleep(1000); 
        //使当前这个线程休眠1000毫秒，从而使新的线程运行waitForever()方法

        System.out.println("Waiting for a moment: " + thread.getState());
        //输出线程的状态

        state.notifyNow(); 
        // 调用state的notifyNow()方法

        System.out.println("Wake up the thread: " + thread.getState());
        //输出线程的状态

        Thread.sleep(1000); 
        //使当前线程休眠1000毫秒，使新线程结束

        System.out.println("Terminate the thread: " + thread.getState());
        //输出线程的状态
    }
}