【操作系统之线程和创建线程】

---

前言

在上篇博客中，我们了解到了进程，那么在篇博客我们将来讲解一下线程，对于作者我而言，我是学习JAVA的，所以跟线程打交道的机会比跟进程打交道的机会多得多(毕竟对于JAVA这个圈子而言，非常鼓励多线程编程)，所以了解线程特别重要

---

一、线程是什么

进程是操作系统分配资源的基本单位。所以进程作为独立运行的基本单位，直到后面，又提出了更小的能独立运行的基本单位，也就是线程。

二、为什么提出线程

这就要从进程来讲解了，首先我们要知道一个观点，进程是一个比较重量级的多处理系统的机制，而线程是一个轻量级的多处理系统的机制，这个重量级和轻量级体现在哪，我们下面可以来好好讨论一下
进程为什么是重量级的呢，这个主要体现在资源分配上，资源分配往往是一个非常耗时的操作

而线程是一个轻量级的（后面讲解为什么），所以我们鼓励多线程编程
进程对于线程的缺点也就展现出来了（虽然多进程编程也可以解决并发问题，但不推荐）

1. 创建一个进程成本比较高
2. 销毁一个进程成本比较高
3. 调度一个进程成本也比较高

所以线程就提出来了，线程则是更轻量级的进程（轻量级进程）
约定：一个进程中可以包含一个或多个线程
这时这多个线程每个线程都是一个独立可以调度的执行流（这些执行流之间是并发的）

这里讲解一下为什么线程是轻量级：因为一个进程里的多个线程共用同一份进程的系统资源（进程包含线程），这意味着对于线程而言，系统资源是已经分配好了的，创建线程就省下了分配资源开销

举个例子：我们有一个工厂生产辣条，卖的十分火爆，供不应求，只有一台机器生产，如下图

这时候我们要想扩展一下，加快辣条生产速度，于是有两个思路
第一种（这种就是进程方式）

我们再租一个院子（申请分配资源），然后把机器搞进去工作（同时工作）

第二种（这种就是线程）

我们可以利用原有的资源，再开一条生产线（成本降低了），除了院子，我们还能共享其他资源，比如原料存储仓库，运输路径等等

小TIP：
1.线程不是进程，如上例子，工厂可以称为进程，而这每台流水线就是线程
2.线程是CPU调度运行的基本单位
3.线程也有自己的私有数据，比如栈和寄存器等

1.线程的上下文切换

关于线程的切换，毕竟线程也是要调度的，所以当去运行其他线程时，就出现了线程的上下文切换
这里有两种情况，我们分别讨论

1.当两个线程不是属于同一个进程，则切换的过程就跟进程上下文切换一样；
2.当两个线程是属于同一个进程，因为内存空间，文件描述符表是共享的，所以在切换时，这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据；

三、线程和进程的区别

1. 进程包含线程
2. 进程有自己独立的内存空间和文件描述符表，同一个进程里的多个线程之间，共享同一份内存空间和文件描述符表（进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈）
3. 进程是操作系统资源分配的基本单位，线程是CPU调度运行的基本单位
4. 进程之间具有独立性，一个进程挂了，不会影响到别的进程，但是同一个进程中的多个线程，一个线程挂了，可能会导致带走整个进程

对于第四条，可以举个例子：
比如为了快速吃完100只烧鸡，于是喊了很多个滑稽老铁来一起吃，但是桌子特别小，所以一次只能几个滑稽老铁上桌子，也就是CPU调度线程，这时候有个滑稽老铁A刚上桌呢，就被挤下去了，他非常
于是，一气之下掀桌子，我吃不到，大家都别想吃，哦豁，这样，整个进程就没了。

四、线程的状态

//线程的状态是一个枚举类型 Thread.State
public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}

1. NEW: 安排了工作（线程还没创建出来）, 还未开始行动（只有个Thread）
2. RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
3. BLOCKED: 这几个都表示排队等着其他事情（表示等待锁出现的状态）
4. WAITING: 这几个都表示排队等着其他事情（使用wait方法出现的状态）
5. TIMED_WAITING: 这几个都表示排队等着其他事情（指定时间等待）
6. TERMINATED: 工作完成了（只有个Thread）

五、线程常见的属性

六、创建线程

- Thread()                           // 创建线程对象
- Thread(Runnable target)            //使用 Runnable 对象创建线程对象
- Thread(String name)                //创建线程对象，并命名
- Thread(Runnable target, String name)   //使用 Runnable 对象创建线程对象，并命名

1.继承Thread类

继承Thread类，然后重写run方法

class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello,thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//最基本的线程
public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while (true) {
            System.out.println("hello,main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

main方法也是一个线程，通常被叫做主线程（两个线程交替执行（达到并发））

2.实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello,thread");
        }
    }
}
//创建一个类实现runnable接口，实例化这个类传给Thread
public class Demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

对比上面两种创建方法 （指代线程方法不同）
继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.
实现 Runnable 接口, this表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread()

3.匿名内部类实现

    public static void main1(String[] args) {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("hello,t1");
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("hello,t2");
            }
        };
        t1.start();
        t2.start();
    }

4.匿名内部类创建 Runnable 子类对象

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

5.lambda 表达式创建 Runnable 子类对象

    public static void main(String[] args) {
        Thread t = new Thread(()-> System.out.println("hello"));
        t.start();
    }

七、多线程执行展示

测试代码

public class Demo5 {
    public  static final long  count = 100_0000_0000l;
    public static void fun1(){
        long beg = System.currentTimeMillis();
        long a = 0;
        long b = 0;
        for (long i = 0; i < count; i++) {
            a++;
        }
        for (long j = 0; j < count; j++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("单线程执行：消耗时间"+ (end-beg)+"ms");
    }
    public static void fun2() throws InterruptedException {
        long beg = System.currentTimeMillis();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                long a = 0;
                for (long i = 0; i < count; i++) {
                    a++;
                }
            }
        });
        t.start();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                long b = 0;
                for (long i = 0; i < count; i++) {
                    b++;
                }
            }
        });
        t1.start();
        t.join();
        t1.join();
        long end = System.currentTimeMillis();
        System.out.println("多线程执行：消耗时间"+(end-beg)+"ms");
    }
    public static void main(String[] args) throws InterruptedException {
        fun1();   //单线程执行
        fun2();   //多线程执行
    }
}

结果

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了线程是什么，为什么会出现线程，如何理解线程的上下文切换，知道了线程和进程的区别，线程的6大状态，线程的常见属性，以及介绍了五个创建线程的办法，对于这五个方法，个人比较推荐第五的一个，因为代码更简洁，不过需要对lambda有一定了解。今天就到此啦。加油！！！