学习问题记录(6) --- 线程

1.volatile关键字有什么作用？

1.volatile关键字的两层语义

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

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

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

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

1 2 3 4 5 6 7 8

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

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

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

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

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

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

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

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

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

　　那么线程1读取到的就是最新的正确的值。

2.编写Java程序模拟烧水泡茶最优工序

package com.uinnova.ftpsynweb.test;

import java.util.concurrent.*;

/**
 * 分工、同步、互斥  烧水泡茶   Thread.join()  CountDownLatch   FutureTask
 *
 */
public class FutureTaskMain {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        FutureTask futureTask = new FutureTask(() -> 1 + 2);
//        ExecutorService service = Executors.newCachedThreadPool();
//        service.submit(futureTask);
//        Object o = futureTask.get();
//        System.out.println(o);
        new FutureTaskMain().run();
    }

    //创建任务T2的FutureTask
    FutureTask<String> ft2 = new FutureTask<>(new T2Task());

    //创建任务T1的FutureTask
    FutureTask<String> ft1 = new FutureTask<>(new T1Task(ft2));

    //线程T1执行任务


    public void run() throws ExecutionException, InterruptedException {
        Thread T1 = new Thread(ft1);
        T1.start();

        Thread T2 = new Thread(ft2);
        T2.start();

        System.out.println(ft1.get());

    }


    //洗水壶、烧水、泡茶
    class T1Task implements Callable<String> {

        FutureTask<String> ft2;

        T1Task(FutureTask<String> ft2) {
            this.ft2 = ft2;
        }

        @Override
        public String call() throws Exception {
            System.out.println("T1:洗水壶...");
            TimeUnit.SECONDS.sleep(1);

            System.out.println("T1:烧开水...");
            TimeUnit.SECONDS.sleep(15);

            //获取T2线程的茶叶
            String tf = ft2.get();
            System.out.println("T1:拿到茶叶：" + tf);

            System.out.println("T1：泡茶...");
            return "上茶： " + tf;
        }
    }

    //洗茶壶、洗茶杯、拿茶叶
    class T2Task implements Callable<String> {


        @Override
        public String call() throws Exception {
            System.out.println("T2 ：洗茶壶...");
            TimeUnit.SECONDS.sleep(1);

            System.out.println("T2：洗茶杯...");
            TimeUnit.SECONDS.sleep(2);

            System.out.println("T2：拿茶叶... ");
            TimeUnit.SECONDS.sleep(1);
            return "龙井";
        }
    }
}