并发编程学习笔记(2)----使用多线程带来的风险

　　说到多线程带来的风险，首先要了解一个概念-临界区。

　　什么是临界区？

　　临界区是用来表示一种公共的资源（共享数据），它可以被多个线程使用，但是在每次只能有一个线程能够使用它，当临界区资源正在被一个线程使用时，其他的线程就只能等待当前线程执行完之后才能使用该临界区资源。

　　比如一台饮水机，比如办公室办公室里有一支笔，它一次只能被一个人使用，假如它正在被甲使用时，其他想要使用这支笔的人只能等甲使用完这支笔之后才能允许另一个人去使用。这就是临界区的概念。

　　使用多线程主要会带来以下几个问题：

　　（一）线程安全问题

　　线程安全问题指的是在某一线程从开始访问到结束访问某一数据期间，该数据被其他的线程所修改，那么对于当前线程而言，该线程就发生了线程安全问题，表现形式为数据的缺失，数据不一致等。

　　线程安全问题发生的条件：

　　　　1）多线程环境下，即存在包括自己在内存在有多个线程。

　　　　2）多线程环境下存在共享资源，且多线程操作该共享资源。

　　　　3）多个线程必须对该共享资源有非原子性操作。

   示例代码：

package com.wangx.thread.t3;

public class Sequence {

    private int value;

    public int getNext() {
        return value++;
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence();

//        while (true) {
//            System.out.println(sequence.getNext());
//        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " " + sequence.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " " + sequence.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

上述代码中多个线程同时调用getNext()方法，该方法对value进行自增的操作，正常的情况下不会出现重复数字或缺失某个数字，但是运行的结果为：

Thread-0 28
Thread-0 30
Thread-1 30
Thread-1 31
Thread-0 31
Thread-1 32
Thread-0 32
Thread-0 33
Thread-1 33

可以看到打印出来的数据有重复数据，这就是产生了线程安全问题，线程安全问题是多线程中很严重的问题，因为任何一个程序，我们都是希望能够得到正确的结果的，所以如果结果不正确，那么程序将变得没有意义，所以我们应该避免线程安全问题的产生。

线程安全问题的解决思路：

　　1）尽量不使用共享变量，将不必要的共享变量变成局部变量来使用。

　　2）使用synchronized关键字同步代码块，或者使用jdk包中提供的Lock为操作进行加锁。

　　3）使用ThreadLocal为每一个线程建立一个变量的副本，各个线程间独立操作，互不影响。

　　（二）性能问题

　　线程的生命周期开销是非常大的，一个线程的创建到销毁都会占用大量的内存。同时如果不合理的创建了多个线程，cup的处理器数量小于了线程数量，那么将会有很多的线程被闲置，闲置的线程将会占用大量的内存，为垃圾回收带来很大压力，同时cup在分配线程时还会消耗其性能。

　　所以在jdk中提出了线程池的概念，模拟一个池，预先创建有限合理个数的线程放入池中，当需要执行任务时从池中取出空闲的先去执行任务，执行完成后将线程归还到池中，这样就减少了线程的频繁创建和销毁，节省内存开销和减小了垃圾回收的压力。同时因为任务到来时本身线程已经存在，减少了创建线程时间，提高了执行效率，而且合理的创建线程池数量还会使各个线程都处于忙碌状态，提高任务执行效率，线程池还提供了拒绝策略，当任务数量到达某一临界区时，线程池将拒绝任务的进入，保持现有任务的顺利执行，减少池的压力。

　　（三）活跃性问题

　　1）死锁，死锁指的是当某一个线程正A在占用临界区资源的使用权，而其必须要另外一临界区资源才能执行完成，但是存在另一个临界区资源正被线程B所占有，且线程B需要线程A持有的资源才能只能完成，这个就会导致两个线程都在等待着对方，从而产生死锁。多个线程环形占用资源也是一样的会产生死锁问题。

　　死锁是一个非常严重的问题，它会导致进程不再工作，是应该避免和时时小心的问题。想要避免死锁，可以使用无锁函数（cas）或者使用重入锁，通过重入锁使线程中断或限时等待可以有效的规避死锁问题。

　　2）饥饿，饥饿指的是某一线程或多个线程因为某些原因一直获取不到资源，导致程序一直无法执行。如某一线程优先级太低导致一直分配不到资源，或者是某一线程一直占着某种资源不妨，导致该线程无法执行等。与死锁相比，饥饿现象还是有可能在一段时间之后恢复执行的。可以设置合适的线程优先级来尽量避免饥饿的产生。

　　3）活锁，活锁体现了一种谦让的美德，每个线程都想把资源让给对方，但是由于机器“智商”不够，可能会产生一直将资源让来让去，导致资源在两个线程间跳动而无法使某一线程真正的到资源并执行，这就是活锁的问题。

　　（四）阻塞

　　阻塞是用来形容多线程的问题，几个线程之间共享临界区资源，那么当一个线程占用了临界区资源后，所有需要使用该资源的线程都需要进入该临界区等待，等待会导致线程挂起，一直不能工作，这种情况就是阻塞，如果某一线程一直都不释放资源，将会导致其他所有等待在这个临界区的线程都不能工作。当我们使用synchronized或重入锁时，我们得到的就是阻塞线程，如论是synchronized或者重入锁，都会在试图执行代码前，得到临界区的锁，如果得不到锁，线程将会被挂起等待，知道其他线程执行完成并释放锁且拿到锁为止。可以通过减少锁持有时间，读写锁分离，减小锁的粒度，锁分离，锁粗化等方式来优化锁的性能。