并发性和多线程（一）

Concurrency

Java是最先支持多线程的开发的语言之一

在过去单CPU时代，单任务在一个时间点只能执行单一程序。之后发展到多任务阶段，计算机能在同一时间点并行执行多任务或多进程。虽然并不是真正意义上的“同一时间点”，而是多个任务或进程共享一个CPU，并交由操作系统来完成多任务间对CPU的运行切换，以使得每个任务都有机会获得一定的时间片运行。

现代的计算机伴随着多核CPU的出现，多线程技术使得在一个程序内部能拥有多个线程并行执行。一个线程的执行可以被认为是一个CPU在执行该程序。当一个程序运行在多线程下，就好像有多个CPU在同时执行该程序。

进程与线程

进程就是正在进行中的程序，线程就是进程中一个负责程序执行的控制单元（执行路径）。

• 一个进程中可以多执行路径，称之为多线程。
• 一个进程中至少要有一个线程。

// 进程
public class Proc {
    public static void main(String[] args) throws Exception {
        Runtime rt = Runtime.getRuntime();
        Process p = rt.exec("notepad.exe"); // 打开记事本
        Thread.sleep(1000); // 等待1秒
        p.destroy(); // 关闭记事本
    }
}

开启多个线程是为了同时运行多部分代码。每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

JVM启动时就启动了多个线程，至少有两个线程可以分析的出来：
1. 执行main函数的线程，该线程的任务代码都定义在main函数中。
2. 负责垃圾回收的线程。

class Demo {
    @Override
    protected void finalize() throws Throwable {
        System.out.println(Thread.currentThread().getName()+"@thread run.."); // 静态方法获取当前线程名称
        super.finalize();
    }
}
public class Thd {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+"@thread run..");
        new Demo();
        System.gc();
        Thread.sleep(100);
    }
} /* Output:
main@thread run..
Finalizer@thread run..
*///:~

多线程的优点和代价

想想这么一个问题，如果一个线程在读一个内存时，另一个线程正向该内存进行写操作，那进行读操作的那个线程将获得什么结果呢？是写操作之前旧的值？还是写操作成功之后的新值？或是一半新一半旧的值？或者，如果是两个线程同时写同一个内存，在操作完成后将会是什么结果呢？是第一个线程写入的值？还是第二个线程写入的值？还是两个线程写入的一个混合值？

因此如没有合适的预防措施，任何结果都是可能的。而且这种行为的发生甚至不能预测，所以结果也是不确定性的。我们在开发中会常常遇见上面的问题，尽管面临着很多的挑战，多线程有一些优点使得它一直被使用。

多线程的优点

• 资源利用率更好
  
  • 假如你要读取本地文件系统的两个文件并进行处理，使用多线程的话，可以在读取第二个文件的同时对第一个文件进行处理。
• 程序设计更简单
  
  • 在单线程中，处理上面的两个文件，需要记录每个文件读取和处理的状态。在多线程中，只需要开启两个线程，每一个线程来用于一个文件的读取和处理。
• 程序响应会更快
  
  • 在Web开发中，当一个请求到来时，我们需要处理这个请求，如果一个请求需要占用大量的时间来处理，在这段时间内新的客户端就无法发送请求给服务端。只有服务器在监听的时候，请求才能被接收。多线程则是监听线程把请求传递给工作者线程，然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。这种具有工作者线程设计的程序显得响应速度更快。

多线程的代价

从一个单线程的应用到一个多线程的应用并不仅仅带来好处，它也会有一些代价。不要仅仅为了使用多线程而使用多线程。而应该明确在使用多线程时能多来的好处比所付出的代价大的时候，才使用多线程。

• 设计更复杂
  
  • 在很多时候多线程应用程序比单线程的应用程序要复杂，在多线程访问共享数据的时候，这部分代码需要特别的注意。线程之间的交互往往非常复杂，不正确的线程同步产生的错误非常难以被发现。
• 上下文切换的开销
  
  • 当CPU从执行一个线程切换到执行另外一个线程的时候，它需要先存储当前线程的本地的数据，程序指针等，然后载入另一个线程的本地数据，程序指针等，最后才开始执行。这种切换称为“上下文切换”（context switch）。上下文切换并不廉价，如果没有必要，应该减少上下文切换的发生。
• 增加资源消耗
  
  • 除了CPU，线程还需要一些内存来维持它本地的堆栈，也需要占用操作系统中一些资源来管理线程。（创建多线程后，即使什么事情都不做，只是在等待，可以看看占用了多少内存）

创建并运行Java线程

任务

创建一个自定义线程时，我们首先都需要明确此线程运行的任务。

编写线程运行时执行的代码（任务）有两种方式：一种是创建java.lang.Thread子类的一个实例并重写run方法，第二种是创建类的时候实现Runnable接口。

• 继承自Thread类，任务就通过覆盖Thread类中的run方法来体现，run方法就是封装自定义线程运行任务的函数。而Thread类自身就实现了Runnable接口。
• 实现接口Runnable，该接口只有一个run方法需要实现。将线程的任务代码封装到run方法中，并将实现了Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。

对于创建线程任务的这两种方式哪种好，并没有一个确定的答案，它们都能满足要求。笔者更倾向于实现Runnable接口这种方法。根据面向对象的思想，我们应该明确任务是否属于Thread继承体系（is a），还仅只是额外的功能，而往往在开发中需要的是一个多线程的功能。此外线程池可以有效的管理实现了Runnable接口的线程，如果线程池满了，新的线程就会排队等候执行，直到线程池空闲出来为止。而如果线程是通过实现Thread子类实现的，这将会复杂一些。

运行

调用线程对象的start方法开启线程。

run方法会在调用start方法之后被执行，一旦线程启动后start方法就会立即返回，而不会等待到run方法执行完毕才返回，就好像run方法是在另外一个CPU上执行一样。

// Java线程的演示
class RunExt extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "@run..");
    }
}
class RunImp implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "@run..");
    }
}
public class Run {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "@run..");
        new RunExt().start(); // 继承自Thread的线程
        new Thread(new RunImp()).start(); // 实现Runnable接口，作为构造函数的参数进行传递
    }
} /* Output: // 输出顺序并不确定，以下是一种输出顺序
main@run..
Thread-1@run..
Thread-0@run..
*///:~

需要注意的是，尽管启动线程的顺序是有序的，但是执行的顺序并非是有序的。JVM和操作系统一起决定了线程的执行顺序，执行顺序和线程的启动顺序并非一定是一致的。

常见错误

创建并运行一个线程所犯的常见错误是调用线程的run方法而非start方法，起初你并不会感觉到有什么不妥，因为run方法的确如你所愿的被调用了。但是事实上run方法并非是由刚创建的新线程所执行的，而是被创建新线程的当前线程所执行了。想要让创建的新线程执行run方法，必须调用新线程的start方法。

public class Run {
    public static void main(String[] args) {
        run();
    }
    public static void run() {
        Thread thread = new Thread("新的线程") { // 自定义线程名
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        };
        thread.run(); // 并没有开启新的线程
    }
} /* Output:
main // 当前线程仍然是main线程，而没有输出：新的线程
*///:~

多线程的状态

在讲解多线程的状态之前，笔者有必要让大家了解一下两个概念：

• CPU的执行资格：可以被CPU处理的，在处理队列中排队。
• CPU的执行权：正在被CPU处理的。

对于上面的这两个概念，举个例子：你在食堂排队（处理队列）打饭，还没有轮到你（此时你仅具有执行资格），过了一段时间后，终于轮到食堂阿姨（CPU）给你打饭（你还在排队中，同时具有执行资格和执行权），当你打完饭你就离开了（释放执行权和执行资格），吃完要是你还是觉得饿，你又会去排队打饭。

在大家明白这两个概念以后，笔者认为多线程的状态有五种：

1. 被创建状态：还未调用start方法开启线程。
2. 运行状态：同时具备执行资格和执行权。
3. 冻结状态：释放执行权的同时释放执行资格。
4. 临时阻塞状态：具备着执行资格，但是不具备执行权，正在等待执行权。
5. 消亡状态：run方法（线程任务）的结束或是调用了stop方法（该方法已过时）。

public class Run {
    public static void main(String[] args) throws InterruptedException {
        stop();
    }
    public static void stop() throws InterruptedException {
        Thread thread = new Thread("新的线程") {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++)
                    System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        };
        thread.start(); // 开启线程
        thread.sleep(5);
        thread.stop(); // 终止线程
    }
} ///~ // 新的线程并没有输出到100就被终止，处于消亡状态

对于运行状态、临时阻塞状态和冻结状态，有一个相互的转换关系。

• 线程的sleep(time)方法：在指定的毫秒数内让当前正在执行的线程休眠，当调用该方法时，会使处于运行状态的线程变为冻结状态，当时间一到，线程自己唤醒，回到临时阻塞状态或者是运行状态。
• 监视器的wait()方法：导致当前线程等待，与sleep方法类似，但是线程不能自己唤醒，需要被该线程的监视器notify()或notifyAll()唤醒。

notify()唤醒该监视器所监视的处于冻结状态的所有线程的任意一个线程，notifyAll()唤醒该监视器所监视的所有冻结线程。（监视器后面会进行介绍）

竞态条件与临界区

当多个线程同时访问同一个资源，并且其中的一个或者多个线程对这个资源进行了写操作，才会产生竞态条件（race conditions）。导致竞态条件发生的代码区称作临界区。

举个例子：有储户a和b向同一个银行存钱，都存三次且每次都存100。

// 银行
class Bank {
    private int sum; // 银行库存
    public void add(int num) { // 每次存钱，库存增加
        sum += num;
        System.out.println(Thread.currentThread().getName() + " sum=" + sum);
    }
}
// 储户
class Customer implements Runnable {
    private Bank bank;
    public Customer(Bank bank) { this.bank = bank; }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) // 存三次，每次存100
            bank.add(100);
    }
}
public class BankDemo {
    public static void main(String[] args) {
        Bank bank = new Bank();
        // 指定a和b储户存钱的银行为bank
        Customer a = new Customer(bank);
        Customer b = new Customer(bank);
        // 开启两个线程可以使a和b同时存钱
        new Thread(a, "a").start(); // 指定线程名为a
        new Thread(b, "b").start(); // 指定线程名为b
    }
} /* Output: // 输出顺序并不确定，以下是一种输出顺序
b sum=200
a sum=200
a sum=400
a sum=500
b sum=300 // 运行程序的电脑为双核（以后会进行解释）
b sum=600
*///:~

通过以上的输出结果可以发现，程序明显有问题！我们可以预料的正确输出应该是从100到600逐步递增。为什么会出现这种情况呢？a和b两个线程同时对银行库存sum进行了写操作，我们无法知道操作系统何时会在两个线程之间切换，具体分析该输出结果的前两条如下：

• b线程获得执行权，进行第一次存钱，调用Bank的add方法时，执行sum += num;语句后，sum库存为100后，还未在主控台打印语句，CPU进行了运行切换，a线程便获得了执行权；
• a线程调用Bank的add方法时，执行sum +=num;语句，sum库存此时为200，还未在主控台打印语句，CPU进行了运行切换，b线程又获得了执行权；
• b线程开始在主控台打印，由于此时sum库存为200，所以打印了200，接着CPU进行了运行切换，a线程获得了执行权；
• a线程也在主控台打印了200。

如果a和b储户不是向同一个银行存钱就不会导致竞态条件。

Bank bank1 = new Bank();
Bank bank2 = new Bank();
Customer a = new Customer(bank1);
Customer b = new Customer(bank2);

线程控制逃逸规则：如果一个资源的创建，使用，销毁都在同一个线程内完成，且永远不会脱离该线程的控制，则该资源的使用就是线程安全的。

资源可以是对象，数组，文件，数据库连接，套接字等等。Java中你无需主动销毁对象，所以“销毁”指不再有引用指向对象。

线程安全及不可变性

多个线程同时读同一个资源不会产生竞态条件，线程安全的代码不包含竞态条件。我们可以通过创建不可变的共享对象来保证对象在线程间共享时不会被修改，从而实现线程安全。

public class ImmutableValue { // 线程安全
    private int value = 0;
    public ImmutableValue(int value) {
        this.value = value;
    }
    public int getValue() { return this.value; }
}

上面这段代码意味着一旦ImmutableValue实例被创建，value（通过构造函数赋值的）成员变量就不能再被修改，这就是不可变性。但你可以通过getValue()方法读取这个变量的值。

public class ImmutableValue { // 也是线程安全
    private int value = 0;
    public ImmutableValue(int value) {
        this.value = value;
    }
    public int getValue() {　return this.value;　}
    public ImmutableValue add(int valueToAdd) {
        return new ImmutableValue(this.value + valueToAdd);
    }
}

请注意add()方法以加法操作的结果作为一个新的ImmutableValue类实例返回，而不是直接对它自己的value变量进行操作，所以也是线程安全的。

即使一个对象是线程安全的不可变对象，指向这个对象的引用也可能不是线程安全的。

public class Calculator {
    private ImmutableValue currentValue = null;
    public ImmutableValue getValue() {
        return currentValue;
    }
    public void setValue(ImmutableValue newValue) {
        this.currentValue = newValue;
    }
    public void add(int newValue) {
        this.currentValue = this.currentValue.add(newValue);
    }
}

Calculator类持有一个成员变量currentValue指向ImmutableValue实例。注意，通过setValue()方法和add()方法可能会改变这个引用。Calculator类本身还是可变的，因此Calculator类不是线程安全的。

要使Calculator类实现线程安全，将getValue()、setValue()和add()方法都声明为同步方法即可。

不变（Immutable）和只读（Read Only）是不同的，当一个变量是“只读”时，变量的值不能直接改变，但是可以在其它变量发生改变的时候发生改变。比如，一个人的出生年月日是“不变”属性，而一个人的年龄便是“只读”属性，但是不是“不变”属性。随着时间的变化，一个人的年龄会随之发生变化，而一个人的出生年月日则不会变化。这就是“不变”和“只读”的区别。