高效并发进阶

一，什么是线程？

打开Windows任务管理器中，可以看到进程和和线程
线程是进程内的执行单元

二，线程的状态转换

首先从创建线程开始，创建线程有3种方式，一种是一个类继承Thread类，第二种是实现Runnable接口，第三种是实现Callable然后用Future创建线程，不同主要是体现单继承和多实现的区别，再者就是这是两个完全不同实现多线程方式，Thread是多个线程分别完成自己的任务，而Runnable是多个线程共同完成一个任务，举个卖票的例子，假设某个类一变量的值为10，假设开启三个线程同时去售票，对于第一种是每个线程都售票10张，这里就是卖了30张，但是对于第二种而然，就是三个线程一共卖了10张。

创建了线程之后就是要启动线程，启动线程就是调用它的start方法，而不是调用run方法，因为调用run是不会开启一个新的线程。当一个线程被启动之后，就会进入到可运行状态，又叫就绪状态，这种状态代表是我已经化好妆，拿好包了，可以随时出门啦，只要收到出门的信息（即获得了CPU分配的时间片）就可以进入到运行状态啦

当进入到运行状态后，其实就是运行run方法里边的内容，当运行玩run方法里边的代码之后，或者main方法结束，该线程生命也就结束了，当然run方法里边一般是有死循环的，不然的话线程就没有意义。这仅仅是一个单线程的生命状态，实际上当我们进入到运行状态的时候，往往是由于业务的繁琐对自身因素做了很多限制，比如线程调用了sleep方法或者其他线程调用了join方法，又或者等待用户的操作等等因素，使得我运行状态被阻塞，要解除阻塞无非就是对应回去，当sleep结束，其他线程跑完了，或者用户输入操作完成，这时候又会从阻塞状态进入可运行状态（就绪），又回到了原点，这时候又要等待CPU的时间片，当然了，回到原点的方式还很多，比如CPU的时间片用完了，或者自己调用了yield（让出CPU时间片，但是自己还是可以在下一轮竞争）

1.线程安全：

　　如果多个线程同时访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那么这个对象是线程安全的。

线程安全的实现方法：

1.互斥同步（阻塞同步）

　　在多线程的大局下，对于并发工作，需要某种方式来防止两个任务访问相同的资源，防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁，也就是大家时常说的synchronized同步，如下

指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

Object.wait() Obejct.notify()需要获得监视器才能使用，执行完之后会释放监视器

//指定加锁对象
public void run() {
    for(int j=0;j<10000000;j++){
        synchronized(this){
             i++;
        }
    }
}

//用在方法上  
public synchronized void increase(){
        i++;
}    

public static synchronized void increase(){
        i++;
}

当线程遇到synchronized关键字的时候，如果已经有线程进入到里边了，此时，该线程就要进入一个等待锁资源的锁池队列，这里的队列是无序的，不是说先到先买的顺序而是公平竞争，抽奖的。很好运，当线程获取到锁资源的时候，线程又回到了可运行状态（就绪），然后又是一轮等待获取CPU时间片，然后继续执行。
当然还有一种情况就是线程获取到锁资源，即进入了用synchronized包着的区域，此时如果是要和其他线程通讯的话，如调用wait方法，会使得该线程释放当前对象锁而进入等待队列，当其他线程拿到了对象锁，然后调用了notify方法或者notifyall后，释放锁资源，在等待的线程会被唤醒，然后进入锁池队列等待获取锁资源，当获得锁资源后，重新进入可运行状态（就绪）然后重复以上过程。注意，这里所说的锁事实上是一个对象监视器，但我认为用锁会比较好理解，锁池队列是阻塞状态。
这种方式是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个线程使用。而互斥是实现同步的一种手段，临界区，互斥量和信号量都是主要的互斥实现方式，因此，互斥是因，同步是果，互斥是方法，同步是目的。

在Java中，最基本的互斥同步手段就是 synchronized关键字， synchronized关键字经过编译之后，会在同步块的前后分别形成 monitorenter和 monitorexit这两个字节码指令，这两个字节码都需要一个 reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那就是这个对象的 reference；如果没有明确指定，那就根据 synchronized修饰的是实例方法还是类方法，去取对应的对象实例或 Class对象来作为锁对象。根据虚拟机规范的要求，在执行 monitorenter指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加1，相应的，在执行 monitorexit指令时会将锁计数器减1，当计数器为0时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止在虚拟机规范对 monitorenter和 monitorexit的行为描述中，有两点是需要特别注意的。首先， synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入，Java的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间。对于代码简单的同步块(如被 synchronized修饰的 getter0或 setter方法)，状态转换消耗的时间有可能比用户代码执行的时间还要长，所以 synchronized是Java语言中一个重量级( Heavyweight)的操作，有经验的程序员都会在确实必要的情况下才使用这种操作，而虚拟机本身也会进行一些优化，譬如在通知操作系统阻塞线程之前加入一段自旋等待过程，避免频繁地切入到核心态之中除了 synchronized之外，我们还可以使用 ava。 util concurrent(下文称JUC)包中的重入锁( Reentrant Lock)来实现同步，在基本用法上， Reentrantlock与 synchronized很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，一个表现为API层面的互斥锁( locko和 unlock方法配合 try/finally语每块来完成)，另一个表现为原生语法层面的互斥锁。不过，相比 synchronized， Reentrantlock增加了一些高级功能，主要有以下3项：等待可中断、可实现公平锁，以及锁可以绑定多个条件。

ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

2.非阻塞同步

互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步( Blocking Synchronization)。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施(例如加锁)，那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁(这里讨论的是概念模型，实际上虚拟机优化掉很大一部分不必要的加锁)、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了：如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施(最常见的补偿措施就是不断地重试，直到成功为止)这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步(Non- Blocking Synchronization)。为什么笔者说使用乐观并发策略需要“硬件指令集的发展”才能进行呢?因为我们需要操作和冲突检测这两个步骤具备原子性，靠什么来保证呢?如果这里再使用互斥同步来保证就失去意义了，所以我们只能靠硬件来完成这件事情，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成,这类指令常用的有TAS测试并设置，FAI获取并增加，CAS比较并交换等，这里重点讲诉CAS，CAS指令有3个操作数，分别是变量的内存地址V，旧的预期值A，新值B，只有当V==A时，处理器把A值更新为B值，否则不执行更新。
举个栗子

public class AtomicTest{
        public static AtomicInteger race=new AtomicInteger(0);
        public stattic void increase(){
                   race.incrementAndGet();
        }

         private static final int THREADS_COUTN=20;

         publie static void main (stringll args) throws Exception {
                     Thread[] threads=new Thread [THREADS_COUNT];
                      for(int i=0;i<THREADS_COUNT;i++){
                            threads[i]=new Thread(new Runnable()){
                                    public void run(){
                                         for(int i=0;i<10000;i++){
                                                 increase(); 
                                         }
                                }      
                            )};
                             threads[i].start();
                      }
                      System.out.println(race);
        }
}

运行结果是20000，使用AtomicInteger代替int后，输出了正确的结果，这一切都归功于increamentAndGet()方法的原子性，而他的实现也是非常简单的，其实就是CAS操作

三，线程的基操

1.创建线程

1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

2】创建Thread子类的实例，也就是创建了线程对象

3】启动线程，即调用线程的start()方法

代码实例

public class MyThread extends Thread{//继承Thread类

　　public void run(){

　　//重写run方法

　　}

}

public class Main {

　　public static void main(String[] args){

　　　　new MyThread().start();//创建并启动线程

　　}

}

1】定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体

2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3】第三部依然是通过调用线程对象的start()方法来启动线程

代码实例：

public class MyThread2 implements Runnable {//实现Runnable接口

　　public void run(){

　　//重写run方法

　　}

public class Main {

　　public static void main(String[] args){

　　　　//创建并启动线程

　　　　MyThread2 myThread=new MyThread2();

　　　　Thread thread=new Thread(myThread);

　　　　thread().start();

　　　　//或者 new Thread(new MyThread2()).start();

　　}

2.终止线程

Thread.stop() 不推荐使用。它会释放所有monitor,导致其他线程设置了锁会无效化

3.中断线程

当run方法中有个死循环的时候，出于某种原因，需要这个线程停下来

掉用t1.interrupt()，这里仅仅是打了个招呼，实际上并没有把线程给终止，还是需要在run方法中对应

public void run(){
    while(true){
        if(Thread.currentThread().isInterrupted()){//判断是否被终
             System.out.println("Interruted!");
             break;
        }
    }
}

4.挂起（suspend）和继续执行（resume）线程

suspend()不会释放锁

如果加锁发生在resume()之前，则死锁发生

5.等待线程结束（join）和谦让(yeild)

join的本质：等待直到本线程执行完毕
while (isAlive()) {
wait(0);
}

yeild是让出CPU时间片，从运行状态变为可运行状态

四，守护线程

在后台默默地完成一些系统性的服务，比如垃圾回收线程、JIT线程就可以理解为守护线程

当一个Java应用内，只有守护线程时，Java虚拟机就会自然退出

Thread t=new DaemonT();
t.setDaemon(true);//设置为守护线程
t.start();

五，线程优先级

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

高优先级的线程更容易再竞争中获胜

Thread high=new HightPriority();
LowPriority low=new LowPriority();
high.setPriority(Thread.MAX_PRIORITY);
low.setPriority(Thread.MIN_PRIORITY);
low.start();
high.start();

六，线程的join和countDownLatch()

首先来看一下join，在当前线程中，如果调用某个thread的join方法，那么当前线程就会被阻塞，直到thread线程执行完毕，当前线程才能继续执行。join的原理是，不断的检查thread是否存活，如果存活，那么让当前线程一直wait，直到thread线程终止，线程的this.notifyAll 就会被调用。