JavaSe之如何创建线程 —— 线程学习（一）

众所周知，线程是Java语言的核心部分，今天我们进入线程的学习，我将首先从概念开始介绍，此处也会涉及到进程与线程的关系。

1. 线程与进程的概念

- 线程概念：

线程，有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。
线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

- 进程的概念
进程就是一次程序的执行，是系统进行资源分配和调度运行的基本单位。
更多详细信息，请点击此处一篇关于进程详细解释的文章
2.线程的分类
线程可以分为单线程与多线程两类。
那么该如何理解这两类线程呢？
单线程：可以是用一根线串起来的线程，即头与尾之间没有交差点；
多线程：不能用一根线串起来的线程，即头与尾之间有交差点；
3. 创建线程的方法
（1）继承Thread类；
（2）实现Runnable接口；
如果你要问哪一种方法好？
那我会告诉你，第二种。因为Thread类也实现了Runnable接口，而且Java编程中允许实现多个接口不允许继承多个类，这一点也符合java编程中单继承多实现的特性。
4. 线程的创建
- 单线程的创建：
单线程的创建比较简单，可以看下面的代码，详细解释附在代码块中：

package com.mec.about_thread
public class SimpleThread{
    public static void main(String[] args) {
        method2(2);
    }   
    public static void method1(int i) {
        System.out.println("这是方法一的结果：" + i);
    }   
    public static void method2(int i) {
        System.out.println("这是方法二的结果：" + i);
        method1(i);
    }
    }

大家都知道，java中程序的执行是从main（)方法开始执行的，那么，我们沿着这个思路来想一下：首先从main方法开始执行method2()方法，当method2()方法传入参数2之时，它会返回到method2()方法的实体中，先执行输出语句，再调用了method1()方法，而且此时的method1()方法传入的参数为2，则现在执行method1()的实体。它是可以串成一条线的。
输出结果应该为：
这是方法二的结果：2
这是方法一的结果：2
我们来看一下结果截图：

- 多线程的创建
一. 使用继承Thread类的方法来创建多线程
步骤如下：
1. 创建一个类SubThread（类名可以任意命名），让这个类继承Thread类；
2. 在这个类中重写run()方法；
3. 在主函数中创建SubThread类的对象；
4. 让这个对象调用start()方法，start()方法的作用有两个：其一启动此线程（是一个新线程）；其二调用相应的run()方法；
其次，我们来看一下代码的实现过程：

package com.mec.about_thread;
public class TestThreads {
    public static void main(String[] args) {
        //步骤三：创建一个线程子类的对象
        SubThread subThread = new SubThread();
        //步骤四：调用相应的start()方法；
        subThread.start();
        //以下两条语句与上面两条语句相似
        SubThread subThread2 = new SubThread();
        subThread2.start();
        //主线程
        for(int i = 100; i < 200; i++) {
            System.out.println("这是主进程的输出****" + Thread.currentThread().getName() + "——>" + i);
        }
    }
}
//步骤一：创建一个类，并继承Thread类
class SubThread extends Thread{
//步骤二：再实现其run()方法，其中run()方法中写的代码会在子线程中执行
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("这是子进程的输出====" + Thread.currentThread().getName() + "——>" + i);
        }
    }
}

我们来看一下运行的部分结果截图：

使用这个方法要注意以下两点：
1.一个线程只能调用一次start()方法；这与Thread类中定义的内部类有关系，与现成的运行状态有关；当第二个线程被调用时，它的状态不再是new,也不符合线程状态为0，因此会抛出异常；
2.不能通过Thread类的实现类来调用run()方法。
二. 使用实现Runnable接口类的方法来创建多线程
步骤如下：
1.创建一个类Run(类名可以任意取，只要首字母大写，并且符合命名规则就好)，实现Runnable接口；
2. 在Run类中实现抽象方法run()方法；
3. 在主函数中，创建Run类的对象；
4. 创建Thread类的对象，并将Run类的对象传入Thread类的构造方法中；
5. 让Thread类的对象调用相应的start()方法；
来看看代码实现：

package com.mec.anotherWayToThreads;
public class TestRunnable {
    public static void main(String[] args) {
        //步骤三：创建实现了Runnable接口的类的对象；
        Run run = new Run();
        //步骤四：创建Thread类的对象，并将Run类的对象传入Thread类的构造器中；
        Thread thread = new Thread(run);        
        Thread thread2 = new Thread(run);
        Thread thread3 = new Thread(run);
        //步骤五：Thread类的对象调用相应的start()方法；
        thread.start();
        thread2.start();
        thread3.start();
    }
}
//步骤一：创建一个类，并且实现Runnable接口；
class Run implements Runnable{
//步骤二：实现Runnable接口中的抽象方法；run()方法中所写的内容就是子线程要执行的内容；
    @Override
    public void run() {
        for(int i = 1; i <= 100; i++) {
            if(i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }   
}

来看看结果截图：

好的，线程初学篇到这里就结束了，期待下一篇~