【Java】一篇文章教会你——线程、指令重排、线程内存模型

微信搜【程序员徐小白】，关注即可第一时间阅读最新文章。回复【面试题】有我准备的50道高频校招面试题，以及各种学习资料。

一、什么是线程

1.进程

要说线程，就要先说一下什么是进程

概念：

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
——百度百科

进程就是在操作系统上拥有资源并且能够独立运行的一个独立单位，每个进程都有各自独立的一块内存空间，内存空间中包含着每个进程的代码和数据空间，进程之间的切换会有较大的开销。一个应用程序想要运行在操作系统上，就要创建一个进程来执行应用程序的代码

2.线程

概念：

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
——百度百科

在早期的操作系统中并没有线程的概念，但是为了进一步地压榨CPU，就诞生了线程这一概念。线程是操作系统中CPU能处理的基本单位，一个进程包含多个线程，在同一进程的线程共享进程中的代码和数据空间，因为每个线程有自己的独立运行的栈和程序计数器，所以线程间的切换开销比较小，可以通过线程的切换，减少IO阻塞的等待时间

3.进程和线程的区别

1. 进程是资源分配的最小单位，线程是CPU调度的最小单位
2. 一个程序至少要有一个进程，一个进程至少要有一个线程
3. 进程之间相互独立，同一进程内的线程共享进程的内存空间和资源
4. 进程之间的切换开销大，线程之间的切换开销小

4.进程和线程的关系

1. 线程必须存在于进程中
2. 线程所使用的资源都是操作系统分配给进程的资源

5.操作系统的任务调度

因为cpu的处理速度十分的快，所以大多数操作系统都是采用时间片轮转的抢占式调度方式，当进程用完了它所分配到的时间片，就会被剥夺CPU的使用权，然后操作系统会选出所有进程中优先级最高的一个进程来占用CPU。
这就可以让多个进程同时运行，但是它们并没有在同一时刻运行。
线程之间的任务调度也是同理的

6.进程和线程的关系示意图

二、线程的使用

1.代码

这里举了一个指令重排的例子，但是我们也能从中学到线程如何使用

/**
 * @author xxj
 *  * 线程测试
 */
public class ThreadTest {
    static int a=0,b=0;
    static int c=0,d=0;
    public static void main(String[] args) throws Exception{
        Thread thread1=new Thread(new Runnable(){
            @Override
            public void run() {
                c=1;
                a=d;
            }
        });
        Thread thread2=new Thread(new Runnable(){
            @Override
            public void run() {
                d=1;
                b=c;
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("a:"+a+" b:"+b+" c:"+c+" d:"+d);
    }
}

2.步骤

1. 首先需要创建一个Runnable接口的实现对象。可以看到我这里是重写了它的run方法的，正常情况下应该先定义一个实现了这个接口的类
2. 创建一个Thread对象，要将刚刚创建的Runnable接口的实现对象放到Thread的构造方法中
3. 调用Thread对象的start方法，就可以启动线程了

3.Thread常用方法

1. start()，启动线程，使用了这个方法，线程就会从新建状态转变成就绪状态
2. sleep()，休眠线程，使用了这个方法，线程就会从运行状态/就绪状态转变成阻塞状态，休眠时间到了就会重新返回就绪状态
3. wait()，挂起线程，使用了这个方法，线程就会从运行状态/就绪状态转变成阻塞状态，线程对象直接使用即可
4. notify()与notifyAll()，唤醒线程，将使用了wait方法的线程从阻塞状态转变为就绪状态

4.Callable线程

/**
 * 有返回值线程的测试
 */
public class CallableTest {
    public static void main(String[] args) {
        //2.创建Callable实现类的实例
        MyCallable callable=new MyCallable();
        //3.创建一个FutureTask<>实例，<>内的数据类型和Callable实现类的一致
        //将callable实现类实例传入构造方法中
        FutureTask<Integer> futureTask=new FutureTask<>(callable);
        //4.创建一个Thread实例，传入FutureTask实例
        Thread thread=new Thread(futureTask);
        //5.启动线程
        thread.start();
        try {
            //6.通过futureTask.get()获取线程返回的值
            System.out.println("子线程返回的值："+futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //1.先创建一个实现了Callable<>的实现类，<>内可以随意填写一个数据类型
    public static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int i=0;
            for (i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"线程"+i);
            }
            //记得返回值
            return i;
        }
    }
}

三、线程的运行状态

1. 新建状态：当一个线程实例被创建时，就会进入新建状态
2. 就绪状态：当线程调用start方法后，线程就会启动，进入就绪状态，可以随时获得cpu资源
3. 运行状态：只有线程处于就绪状态，然后获得cpu资源才能进入运行状态，线程就会去运行run方法内的代码
4. 阻塞状态：当线程所分配的时间片到了，或者是遇到了io阻塞，再者主动调用一些方法，就会进入阻塞状态。当再次分配到cpu资源、io准备完成、主动调用方法唤醒线程时，就会转成就绪状态
5. 死亡状态：进入死亡状态的线程，它的整个生命周期就结束了

四、线程的组成

1.线程标识符（ThreadID）

ThreadID就是每个线程的标识符，如果两个线程ID是一样的，那么它们就是同一个线程

2.线程本地存储（TSL）

TSL全称thread local storage，是每个线程的私有内存空间，与进程中共享的内存空间相互独立

3.程序计数器（PC）

PC全称Program Counter，程序计数器存放着程序指令的地址，当cpu执行这个线程时，就会根据程序计数器里的地址寻找到对应的指令，然后让程序计数器指向下一条指令的地址。

4.栈

这个栈也是线程私有的栈，用来执行线程方法的指令

五、线程安全

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。
——百度百科

线程安全关注的点就是，当多个线程运行时，会不会对一个数据造成污染，一般是进程共享内存中的共享数据
数据污染原因：
在线程执行指令时，会先将内存中的共享数据拷贝到本地，然后进行操作，再赋值回内存中，如果多个线程同时拷贝，那就只有一个线程操作后的数据会赋值回内存中，这就会造成数据污染。
解决方法：
这时，就需要给数据加上synchronized/Lock或volatile，给数据加个锁或者赋予内存可见性，这样就不会造成数据污染了
这样就会让每个线程的操作具有原子行，有点类似于，数据库中的事物。

六、总结

线程必须依附于进程，并且要占用进程的资源和内存空间，但每个线程都有自己私有的内存空间。使用线程能够提高对cpu的利用率，因为线程的切换比进程的切换开销要小，但是需要注意线程安全问题

——————————————————————————————
你知道的越多，不知道的越多。

如果本文章内容有问题，请直接评论或者私信我。如果觉得写的还不错的话，点个赞也是对我的支持哦

未经允许，不得转载！