java多线程并发执行并等待结果

一、进程和线程区别？

进程：进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。（进程是资源分配的最小单位）。
线程：一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）。

二、并发和并行区别？

并发任务强调在一个时间段内同时执行，而一个时间段由多个单位时间累积而成，所以说并发的多个任务在单位时间内不一定同时在执行。在单CPU的时代多个任务都是并发执行的。

图所示为双CPU配置，线程A和线程B各自在自己的CPU上执行任务，实现了真正的并行运行。

而在多线程编程中，线程的个数往往多于CPU的个数，所以一般都称多线程并发编程而不是多线程并行编程。

区别：

并发:一个处理器同时处理多个任务。它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状态。
并行: 多个处理器或者是多核的处理器同时处理多个不同的任务。两个线程互不抢占CPU资源，可以同时进行。

三、java共享变量内存的可见性

Java内存模型规定，将所有的变量都存放在主内存中，当线程使用变量时，会把主内存里面的变量复制到自己的工作空间或者叫作工作内存，线程读写变量时操作的是自己工作内存中的变量。Java内存模型是一个抽象的概念。

实际中线程的工作内存是：

图中所示是一个双核CPU系统架构，每个核有自己的控制器和运算器，其中控制器包含一组寄存器和操作控制器，运算器执行算术逻辑运算。每个核都有自己的一级缓存，在有些架构里面还有一个所有CPU都共享的二级缓存。那么Java内存模型里面的工作内存，就对应这里的L1或者L2缓存或者CPU的寄存器。

当一个线程操作共享变量时，它首先从主内存复制共享变量到自己的工作内存，然后对工作内存里的变量进行处理，处理完后将变量值更新到主内存。

因为有缓存的存在，在并发编程时，会出现内存不可见问题。
例子如下：
假如线程A和线程B同时处理一个共享变量，我们使用上图所示CPU架构，假设线程A和线程B使用不同CPU执行，并且当前两级Cache都为空。
●线程A首先获取共享变量X的值，由于两级Cache都没有命中，所以加载主内存中X的值，假如为0。然后把X=0的值缓存到两级缓存，线程A修改X的值为1,然后将其写入两级Cache,并且刷新到主内存。线程A操作完毕后，线程A所在的CPU的两级Cache内和主内存里面的X的值都是1。
●线程B获取X的值，首先一级缓存没有命中，然后看二级缓存，二级缓存命中了，所以返回X= 1 ;到这里一切都是正常的，因为这时候主内存中也是X=1。然后线程B修改X的值为2,并将其存放到线程2所在的一级Cache和共享二级Cache中，最后更新主内存中X的值为2;到这里一切都是好的。
●线程A这次又需要修改X的值，获取时一级缓存命中，并且X=1，到这里问题就出现了，明明线程B已经把X的值修改为了2，为何线程A获取的还是1呢?这就是共享变量的内存不可见问题，也就是线程B写入的值对线程A不可见。

使用Java中的volatile、synchronized关键字就可以解决这个问题。

四、synchronized内存语义

解决共享变量内存可见性问题
前面介绍了共享变量内存可见性问题主要是由于线程的工作内存导致的，这个内存语义就可以解决共享变量内存可见性问题。进入synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除，这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取，而是直接从主内存中获取。退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。
synchronized中文意思是同步，也称之为”同步锁“。
synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。
synchronized经常被用来实现原子性操作。
synchronized关键字会引起线程上下文切换并带来线程调度开销。

它修饰的对象有以下几种：
　　1). 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
　　2). 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
　　3). 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
　　4). 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

五、volatile关键字

在Java中为了加快程序的运行效率，对一些变量的操作通常是在该线程的寄存器或是CPU缓存上进行的，之后才会同步到主存中，而加了volatile修饰符的变量则是直接读写主存。也是解决共享变量内存可见性问题。
volatile三个特性：(1)保证可见性，(2)不保证原子性，(3)禁止指令重排

5.1 volatile的可见性

上面介绍了使用锁的方式可以解决共享变量内存可见性问题，但是使用锁太笨重，因为它会带来线程上下文的切换开销。对于解决内存可见性问题，Java 还提供了一种弱形式的同步，也就是使用volatile关键字。该关键字可以确保对一个变量的更新对其他线程马上可见。当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。当其他线程读取该共享变量时，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。
示例：

public class VolatileTest {
    public static volatile boolean flag = false;
    public static void main(String[] args) throws InterruptedException {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

        new Thread(threadA, "threadA").start();
        Thread.sleep(1000l);//为了保证threadA比threadB先启动，sleep一下
        new Thread(threadB, "threadB").start();
    }

    static class ThreadA extends Thread {
        public void run() {
            while (true) {
                if (flag) {
                    System.out.println(Thread.currentThread().getName() + " : flag is " + flag);
                    break;
                }
            }
        }
    }
    static class ThreadB extends Thread {
        public void run() {
            flag = true;
            System.out.println(Thread.currentThread().getName() + " : flag is " + flag);
        }
    }
}

本例子中可以看到volatile和不加volatile的区别。

不加volatile，ThreadA无法看到ThreadB变化后的flag，所以会一直死循环。

加上volatile，ThreadA能看到ThreadB变化后的flag，所以退出

5.2 volatile同步的理解（不能保证原子性）

使用synchronized 关键宇进行同步的方式。

然后是使用volatile 进行同步。

volatile无法保证原子性

示例：

public class VolatileTest1 {

    public volatile int inc = 0;
    public  void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest1 test = new VolatileTest1();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
        //休眠1秒
        Thread.sleep(1000);
        System.out.println(test.inc);
    }
}

inc++不是原子的，简单的一行代码是由读—>加一来完成，不具有原子性。
所以可以看出：
（1）从而我们可以看出volatile虽然具有可见性但是并不能保证原子性。
（2）性能方面，synchronized关键字是防止多个线程同时执行一段代码，就会影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized。

但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。

5.3 volatile禁止指令重排

指令重排序是指编译器和处理器为了优化程序性能而对指令序列进行排序的一种手段。
但是重排序也需要遵守一定规则：
　　1.重排序操作不会对存在数据依赖关系的操作进行重排序。
　　　　比如：a=1;b=a; 这个指令序列，由于第二个操作依赖于第一个操作，所以在编译时和处理器运行时这两个操作不会被重排序。
　　2.重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执行结果不能被改变。
示例：
比如：a=1;b=2;c=a+b这三个操作，第一步（a=1)和第二步(b=2)由于不存在数据依赖关系，所以可能会发生重排序，但是c=a+b这个操作是不会被重排序的，因为需要保证最终的结果一定是c=a+b=3。
　　重排序在单线程模式下是一定会保证最终结果的正确性，但是在多线程环境下，就会出现问题。

public class VolatileTest2 {

    public static class ReadThread extends Thread {
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                if (ready) {// (1)
                    System.out.println(num + num);// (2)
                }
                System.out.println("read thread....");
            }
        }
    }

    public static class Writethread extends Thread {
        public void run() {
            num = 2;//(3)
            ready = true;// (4)
            System.out.println("writeThread set over...");
        }
    }

    private static int num = 0;
    private static boolean ready = false;

    public static void main(String[] args) throws InterruptedException {
        ReadThread rt = new ReadThread();
        rt.start();
        Writethread wt = new Writethread();
        wt.start();
        Thread.sleep(10);
        rt.interrupt();
        System.out.println("main exit");
    }
}

写volatile变量时，可以确保volatile写之前的操作不会被编译器重排序到volatile写之后。
读volatile变量时，可以确保volatile读之后的操作不会被编译器重排序到volatile读之前。