如何创建线程？如何保证线程安全？

Posted 2023-05-16

创建线程的方式一：继承Thread类（由于Java单继承的特性，这种方式用的比较少）

步骤：

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



请点击输入图片描述

2、创建子类对象，然后调用start()方法来启动线程



请点击输入图片描述

我们可以看到这边现在只创建了一个线程，那么如果要创建多个线程要怎么做呢？通过继承Thread的方式创建线程，想要创建多个不同的线程就要先创建多个不同的继承Thread的类，然后再根据上面的步骤1,2来创建线程，这显然有些麻烦，为了展示多线程，我们先在上面的线程中增加一个主线程，也就是main方法中执行的线程。如下：



请点击输入图片描述

创建线程的方式二：实现Runnable接口（Java可以实现多个接口，这种方式常用）

步骤：

1、创建一个类实现Runnable接口，然后重写run方法



请点击输入图片描述

2、创建实现类对象、代理类对象，然后代理类对象调用start()方法启动线程

用实现Runnable接口的方式，实现多线程：

《模拟抢票系统》，代码如下：

线程调用了start()方法，并不意味着立即执行，而是到就绪状态，等待cpu的调度，所以每次执行的结果都是不一样的。

创建线程的方式三：实现java.util.concurrent并发包下的Callable接口（进阶版，初学者做个了解）

步骤：

1、创建一个类实现Callable接口，然后重写call()方法

（和run方法不一样的是，call方法可以有返回值，并且可以抛出异常）

2、创建Callable的实现类对象--》创建执行服务--》提交执行服务得到Future对象--》获取结果--》停止服务

参考技术A 创建线程安全类的关注点

一个类要想线程安全，除了上一篇文章通过外部解决方式外，还可以通过合理的设计类的内部来解决，使类本身就线程安全，那么要怎么才能使类是线程安全的呢？
类不是线程安全的原因主要就是它包含了一些属性，这些属性是这个类实例对象的变量，这些变量影响着对象状态，由于对这些属性的访问在多线程情况下出现一些不安全使得对象状态并不符合预期导致类的不安全，所以设计线程安全类大概方向就是保证这些影响对象状态的变量，在Java并发编程实战中的总结如下：
找出构成对象状态的所有变量；
找出约束状态变量的不变性条件；
建立对象状态的并发访问管理策略；
这里先解释下不变性条件，在一些类的它的一些变量的变化是有一定规则的，比如类中定义一个属性表示苹果卖出了多少斤，卖出就增加，退货就减少，但是它肯定不会是一个负值，不为负值这就是这个变量的不变性条件。在比如类中定义了最大值与最小值，那么在这两个变量只有有一个不变性条件就是最大值要大于等于最小值。

简单解释了不变性条件再来理解下上面3条：可以把这3条分成3个步骤，首先是找出构成对象状态的所有变量，第二步是找出变量的约束条件，最后是上面两步找出的变量进行并发访问控制保证不变性条件的约束，对比较独立的属性直接进行并发访问，但是对有关联的那就必须要更多的机制保证这个约束。

所以我们可以把设计线程安全的类步骤分成以下三块：
1、找出所有需要同步的属性，保证不可变条件和后验条件（方法执行后必须为真的条件），比如上面举的卖出苹果的重量，比如最大值与最小值关系；
2、保证一些依赖一些状态的操作正确执行（先验条件方法执行前必须为真的条件），比如单例模式中实体为null的时候才初始化；
3、一定要控制这些属性的所有权，基础类型的属性可能比较好控制，有些是引用类型但又要保证线程安全的，那就要严格控制所有权，否则有可能其他线程拿到这个引用进行修改这个对象的内容，造成线程不安全；
已有对象如何保证线程安全
我们可以设计出线程安全的类，但是有可能有些对象已经存在，然后它并不是线程安全，现在却需要保证它的线程安全，那该如何做呢？
通过监视器模式实现，把对象封装到一个新对象里面，所有对这个对象的访问都通过新对象的方法访问，然后保证新对象的方法是线程安全的就行了。
并不一定需要自己实现线程安全

但是有时候我们并不是一定要设计成线程安全的类，如果已经存在一些线程安全的类可以保证我们需要的线程安全，还是要尽量用现有的，比如上面提到过苹果卖出的重量，就可以利用AtomicInteger来保证安全，再比如一些缓存也可以用ConcurrentMap来保证线程安全，把我们需要保证的线程安全委托给一些线程安全的类。
但是委托并不是一定有用的，比如前面的最大、最小值例子，如果定义成现AtomicInteger也无法保证它们的不可变条件的约束！这种可能就只能加锁了，但是如果他们两个并没有不可变条件约束是两个无关的共享变量，还是可以把多个无关的状态变量委托给线程安全的类。

如何扩展线程安全类
那么如果一个线程安全的类功能不满足我们的需求，需要扩展一些功能，可是又不能修改这个类，那么就必须要对这个类进行扩展，扩展分两种方法继承、客户端扩展。继承实现比较简单，继承的类只要在保证新增的方法是线程安全的，那么它整个都是线程安全的，不过客户端扩展可能情况复杂一点. 参考技术B 1.不可变 在java语言中,不可变的对象一定是线程安全的,无论是对象的方法实现还是方法的...
2.绝对线程安全 绝对的线程安全完全满足Brian GoetZ给出的线程安全的定义,这个定义...
3.相对线程安全 相对线程安全就是我们通常意义上所讲的一个类是“线程安全”的。 它需要保证对...
4.线程兼容 线程兼容就是我们通常意义上所讲的一个类不是线程安全的。 线程兼容是指对象本身并... 参考技术C 创建多线程程序的第一种方式:创建Thread类的子类 ，
创建多线程程序的第二种方式:实现Runnable接口。一般说来，确保线程安全的方法有这几个：竞争与原子操作、同步与锁、可重入、过度优化。

为什么会有多线程？什么是线程安全？如何保证线程安全？

本文将会回答这几个问题：

1. 为什么会有多线程？

2. 什么是线程安全？

3. 怎么样保证线程安全？

为什么会有多线程

什么是线程安全

在谈什么是线程安全的问题之前，先给大家举一个线程不安全的例子，直接上代码

public class Test {
    private static int count;
    private static class Thread1 extends Thread {
        public void run() {
            for (int i = 0; i < 1000; i++) {
                count ++;
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread1  t1 = new Thread1();
        Thread1  t2 = new Thread1();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

这段代码实现的逻辑很简单，首先定义了一个int型的count变量，然后开启了两个线程，每个线程执行1000次循环，循环中对count进行加1操作。等待两个线程都执行完成后，打印count的值。那么这段代码的输出结果是多少呢？可能很多人会说是2000。但是程序运行后却发现结果大概率不是2000，而是一个比2000略小的数，比如1998这样，而且每次运行的结果可能都不相同。
那么这是为什么呢？这就是线程不安全。线程安全是指在多线程环境下，程序可以始终执行正确的行为，符合预期的逻辑。比如我们刚刚的程序，共两个线程，每个线程对count变量累加1000次，预期的逻辑是count被累加了2000次，而代码执行的结果却不是2000，所以它是线程不安全的。
为什么是不安全的呢？因为count++的指令在实际执行的过程中不是原子性的，而是要分为读、改、写三步来进行；即先从内存中读出count的值，然后执行+1操作，再将结果写回内存中，如下图所示。

线程交替执行

这就是线程在计算机中真实的执行过程，看起来好像没问题啊，别急，再看一张图

不安全的线程交替执行

看出来问题了么？上图中线程1执行了两次自加操作，而线程2执行了一次自加操作，但是count却从6变成了8，只加了2.我们看一下为什么会出现这种情况。当线程1读取count的值为6完成后，此时切换到了线程2执行，线程2同样读取到了count的值为6，而后进行改和写操作，count的值变为了7；此时线程又切回了线程1，但是线程1中count的值依然是线程2修改前的6，这就是问题所在！！！即线程2修改了count的值，但是这种修改对线程1不可见，导致了程序出现了线程不安全的问题，没有符合我们预期的逻辑。
相信大家现在已经对线程不安全已经有了一定的认识了。现在我们总结一下导致线程不安全的原因，主要有三点：

• 原子性：一个或者多个操作在 CPU 执行的过程中被中断

• 可见性：一个线程对共享变量的修改，另外一个线程不能立刻看到

• 有序性：程序执行的顺序没有按照代码的先后顺序执行

前两点前面已经举例了，现在在解释一下第三点。为什么程序执行的顺序会和代码的执行顺序不一致呢？java平台包括两种编译器：静态编译器（javac）和动态编译器（jit:just in time）。静态编译器是将.java文件编译成.class文件（二进制文件），之后便可以解释执行。动态编译器是将.class文件编译成机器码，之后再由jvm运行。问题一般会出现在动态编译器上，因为动态编译器为了程序的整体性能会对指令进行重排序，虽然重排序可以提升程序的性能，但是重排序之后会导致源代码中指定的内存访问顺序与实际的执行顺序不一样，就会出现线程不安全的问题。

如何保证线程安全

下面简单谈谈针对以上的三个问题，java程序如何保证线程安全呢？
针对问题1：JDK里面提供了很多atomic类，比如AtomicInteger, AtomicLong, AtomicBoolean等等，这些类本身可以通过CAS来保证操作的原子性；另外Java也提供了各种锁机制，来保证锁内的代码块在同一时刻只能有一个线程执行，比如刚刚的例子我们就可以加锁，如下：

synchronized (Test.class){
    count ++;
}

这样，就能够保证一个线程在多count值进行读、改、写操作时，其他线程不可对count进行操作，从而保证了线程的安全性。
针对问题2：同样可以通过synchronized关键字加锁来解决。与此同时，java还提供了一种轻量级的锁，即volatile关键字，要优于synchronized的性能，同样可以保证修改对其他线程的可见性。volatile一般用于对变量的写操作不依赖于当前值的场景中，比如状态标记量等。
 针对问题3：可以通过synchronized关键字定义同步代码块或者同步方法保障有序性，另外也可以通过Lock接口保障有序性。
怎么样？现在是不是对线程安全有了更加深入的理解了呢？