java并行程序基础

java并行程序基础

基本方法

run 和 start方法的区别

run方法里面写的是线程要执行的内容。直接使用run方法并没有新建一个线程程序还是串行执行的，start 方法才会真正的开启一个线程，执行run方法。

stop 方法

stop方法被禁用的原因就是stop方法太暴力了，它会终止一个执行到一半的线程，这样会导致很多错误。

需求：user对象的id和code要相等，如果使用stop方法可能会导致意外情况

代码如下

public class UnsafeStopThread {
    static final User user = new User();

    @Getter
    @Setter
    public static class User {
        private long id;
        private long code;
        public User() {
            id = 0L;
            code = 0L;
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", code=" + code +
                    '}';
        }
    }

    public static class ChangeObjectThread extends Thread {
        @Override
        public void run() {
            while (true){
                synchronized (user) {
                    long l = System.currentTimeMillis();
                    user.setId(l);
                    //do thing else
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    user.setCode(l);
                }
                Thread.yield();
            }
        }
    }

    public static class ReadObjectThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (user) {
                    if (user.getId() != user.getCode()){
                        System.out.println(user.toString());
                    }
                }
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ReadObjectThread().start();
        while (true) {
            ChangeObjectThread thread = new ChangeObjectThread();
            thread.start();
            Thread.sleep(100);
            thread.stop();
        }
    }
}

id 和 code 就会出现不一样的情况，在现实开发中会导致数据损坏后果严重。

解决办法 interrupt 方法

public boolean isInterrupted()//判断当前线程是否是中断状态，不会影响线程的中断状态
public static boolean interrupted()//判断当前线程是都是中断状态，并清除中断状态
public void interrupt()//标记当前线程为中断状态

public static class ChangeObjectThread extends Thread {
    @Override
    public void run() {
        while (true){
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(" interrupted ");
                break;
            }
            synchronized (user) {
                long l = System.currentTimeMillis();
                user.setId(l);
                //do thing else
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println(" interrupted when sleep");
                }
                user.setCode(l);
            }
            Thread.yield();
        }
    }
}

public static native void sleep(long millis) throws InterruptedException;

如果 当前线程被中断的时候，线程正好处于 sleep 状态 那么会抛出异常并清除中断标志，所以在捕获异常的时候，再把当前线程设置为中断状态。

实验结果

notify 和 wait 方法

notify 和 wait 方法都是定义在Obj中的，他们要被包含在对应的 synchronzied 语句中，如果一个线程调用了obj.wait 那么他就会释放当前的监视对象并进入该对象的等待队列，当某个线程调用obj.notify 方法的时候就会从等待队列里面完全地随机唤醒一个线程，唤醒的线程不能立即继续执行，而是要获得监听器才能继续执行。wait 和 notify方法掉用之前都必须获取对应的监听器。

实验

public class SimpleNW {
    static final Object obj = new Object();
    public static class T1 extends Thread {
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println(System.currentTimeMillis() + " T1 start");
                try {
                    System.out.println(System.currentTimeMillis() + " T1 wait Obj");
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + " T1 end");
            }

        }
    }

    public static class T2 extends Thread {
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println(System.currentTimeMillis() + " T2 start");
                obj.notify();
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + " T2 end");
            }

        }
    }

    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        t1.start();
        t2.start();
    }
}

sleep 也可以让线程等待若干的时间，但wait方法可以被唤醒，并且wait方法会释放锁，但是sleep方法不会释放任何资源。

join 和 yield 方法

join 表示当前线程需要其他线程加入并且只有当加入的线程执行完毕之后才会继续执行当前线程。

测试

public class JoinThread {
    static int i = 0;
    public static class JoinTest extends Thread {
        @Override
        public void run() {
            for (;i < 1000;i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        joinTest.start();
        joinTest.join();
        System.out.println(i);
    }
}

如果没有 joinTest.join(); 那么 i 可能是一个很小的值，但是主线程愿意让 joinTest 线程加入，它同意等待 joinTest 执行玩在执行所以输出的结果是 1000.

join 方法的本质是当前线程调用 wait 方法，在当前线程对象上进行等待，加入的线程退出之前会调用notifyAll 方法通知所有的等待线程继续执行。

yield 方法是表示让出CPU资源，但是让出CPU之后，他会和其他线程一起继续争夺CPU资源

java内存模型和violatile

JMM

JMM的关键技术点都是围绕多线程的原子性，可见性，有序性来进行建立的。是为了保证程序在多线程情况下正常运行

原子性

原子性是指一个操作不能被中断，比如给 int i 赋值，线程 A 赋值为 1 ，线程 B 赋值为 -1 那么i 的值要么是 1 要么是 -1。

假设在32位的电脑中，如果i 是 long 类型 而不是 int 类型那么赋值操作不会是原子性的了，因为int是32位，但是 long 是64位。多个线程同时对long写入的同时如果还有一个线程在读的话，读出来的数值就会出现问题的，例如前32位是线程A赋值的，而后三十二位是线程B赋值的。

java中提供了synchronized关键字来实现原子性的。

可见性

可见性是指一个线程对全局变量进行修改的时候，其他的线程也能知道该变量被修改了。这对于并行程序来讲可能会出现问题，如果CPU1和CPU2同时运行一个线程，全局变量 t 是他们的共享资源，那么当CPU1对变量t 进行修改的时候，由于CPU1可能对变量t 进行了缓存（存储在cache或者寄存器中），那么CPU2 是不会知道变量t 已经进行了修改的。

有序性

有序性是指代码从前往后执行，在编写的逻辑上没有问题，但是执行的时候可能是写在后面的代码后执行，这是因为指令的重排，指令的重排可以保证串行语义一致，但是不能保证多线程间的语义一致。比如

指令重排是为了提高性能，一次指令的执行会用到不同的硬件资源，把这些步骤隔开，形成流水线，有时候后一条指令要前一条指令的运行结果，那么等他取指和译码之后，就需要等待，而后面的其他指令不需要等前面的指令，那么让后面的指令先执行就可以提高效率。

volatile

violatile 关键字是 java 为了解决之前提到过了原子性 可见性和有序性提供的关键字之一。

1.volatile关键字的两层语义

　　一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

　　1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

　　2）禁止进行指令重排序。

　　先看一段代码，假如线程1先执行，线程2后执行：

//线程1
boolean stop = false;
while (!stop){doSomething();}

//线程2
stop = true;

　这段代码是很典型的一段代码，很多人在中断线程时可能都会采用这种标记办法。但是事实上，这段代码会完全运行正确么？即一定会将线程中断么？不一定，也许在大多数时候，这个代码能够把线程中断，但是也有可能会导致无法中断线程（虽然这个可能性很小，但是只要一旦发生这种情况就会造成死循环了）。

　　下面解释一下这段代码为何有可能导致无法中断线程。在前面已经解释过，每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份放在自己的工作内存当中。

　　那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

volatile 保证可见性

//线程1
volatile boolean stop = false;
while (!stop){doSomething();}

//线程2
stop = true;

但是用volatile修饰之后就变得不一样了：

　　第一：使用volatile关键字会强制将修改的值立即写入主存；

　　第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

　　第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

　　那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。

　　那么线程1读取到的就是最新的正确的值。所以volatile 保证可见性

volatile 不保证原子性

public class VolatileTest {
     volatile int i = 0;

    private  void increase() {
        i++;
    }

    public static void main(String[] args) {
        VolatileTest test = new VolatileTest();
        for (int j = 0; j < 10; j++) {
            new Thread() {
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        test.increase();
                    }
                }
            }.start();
        }

        while (Thread.activeCount() > 1) {
            Thread.yield();
        }

        System.out.println(test.i);
    }
}

按道理说值会是1000，但是测试的值往往小于1000，所以 volatile 不保证原子性。

　　可能有的朋友就会有疑问，不对啊，上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终inc的值应该是1000*10=10000。

　　这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

　　在前面已经提到过，自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

　　假如某个时刻变量inc的值为10，

　　线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

　　然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

　　然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

　　那么两个线程分别进行了一次自增操作后，inc只增加了1。

volatile 保证一定的有序性

　在前面提到volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。

　　volatile关键字禁止指令重排序有两层意思：

　　1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

　　2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

//x、y为非volatile变量
//flag为volatile变量
x = 2;        //语句1
y = 0;        //语句2
flag = true;  //语句3
x = 4;         //语句4
y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

volatile 原理

volatile的原理和实现机制

前面讲述了源于volatile关键字的一些使用，下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。

下面这段话摘自《深入理解Java虚拟机》：

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

　　1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

　　2）它会强制将对缓存的修改操作立即写入主存；

　　3）如果是写操作，它会导致其他CPU中对应的缓存行无效。