java并发编程实战wwj----------------------第二阶段--------------04-05--06--07-8-9-10-11

最新推荐文章于 2020-05-20 07:52:26 发布

nzch

最新推荐文章于 2020-05-20 07:52:26 发布

阅读量185

点赞数

分类专栏：并发 wwj并发

本文链接：https://blog.csdn.net/qq_28764557/article/details/103616479

版权

并发同时被 2 个专栏收录

99 篇文章 0 订阅

订阅专栏

wwj并发

14 篇文章 0 订阅

订阅专栏

代码：

wait线程放弃了cpu的执行权进入wait状态。

Optional.of:https://www.cnblogs.com/baidawei/p/9443402.html

看下这个英文的解释。

这个是一个虚的概念，因为你在它里面拿不出任何的东西，但是它确实是去存放我们的线程的。

线程里面执行了wait之后会把自己放在锁住得对象的wait set里面去的。任何一个对象都有一个

wait set。

public class WaitSet {
    private static final Object LOCK = new Object();

    public static void main(String[] args) {
        IntStream.rangeClosed(1, 10).forEach(i -> {
            new Thread(String.valueOf(i)) {
                public void run() {
                    synchronized (LOCK){
                        try {
                            Optional.of(Thread.currentThread().getName()+" will be to wait set").ifPresent(System.out::println);
                            LOCK.wait();
                            Optional.of(Thread.currentThread().getName()+" will leave to wait set").ifPresent(System.out::println);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        });

        try {
            Thread.sleep(3_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        IntStream.rangeClosed(1, 10).forEach(i -> {
            synchronized (LOCK){
                LOCK.notify();
                try {
                    Thread.sleep(1_000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

    }
}

wait和notify都是lock对象去完成的。和线程本身是没有关系的。

---

代码：

关键的总结：

我再次起来会拿到begin......吗？

public class WaitSet2 {
    private static final Object LOCK = new Object();

    public static void work() {
        synchronized (LOCK) {
            System.out.println("begin......");
            try {
                System.out.println("Thread will comming......");
                LOCK.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Thread will end......");
        }
    }


    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                work();
            }
        }.start();
        Thread.sleep(1_000);
        synchronized (LOCK){
            LOCK.notify();
        }
    }
}

有地址恢复顺着执行的单元去执行。

再次抢到锁的话是执行的end

--------------------------------------------------04-----------------------------------------------------------------------

volatile：

代码：

public class VolatileTest {
//    private volatile static int INIT_VALUE = 0;
//    private static int INIT_VALUE = 0;
    private final static int MAX_LIMIT = 5;

    public static void main(String[] args) {
        new Thread(() -> {
            int localValue = INIT_VALUE;
            while (localValue < MAX_LIMIT) {
                if (localValue != INIT_VALUE) {
                    System.out.println("The value READER to" + INIT_VALUE);
                    localValue = INIT_VALUE;
                }
            }
        }, "READER").start();
        new Thread(() -> {
            int localValue = INIT_VALUE;
            while (localValue < MAX_LIMIT) {
                System.out.println("The value UPDATE to" + (++localValue));
                INIT_VALUE = localValue;
                try {
                    Thread.sleep(5_00);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "UPDATE").start();
    }
}

不加volatile打印：

线程的可见行：https://blog.csdn.net/dyllove98/article/details/8580734

这个就是不主动去主存里面去刷新缓存的。看前面的链接有讲的。

-----------------------------------------05------------------------------------------------

线程的基本特性：原子性有序性可见行。

volatile不能保证原子性的。

volatile：内存可见性(读一定再写完之后的) 有序性。

内存RAM，计算是放在CPU的寄存器的。

cpu--------cpu的cache-------ROM

cpu快，但是RAM慢，所以则加个缓冲区就是内存条。

cpu1和cpu2指的是不同的cpu的核。

JMM模型：https://blog.csdn.net/lxm55913153/article/details/79208126

每个线程都是修改自己本地的缓存的数据再更新到主存。

public class VolatileTest2 {
    //private volatile static int INIT_VALUE = 0;
    private static int INIT_VALUE = 0;
    private final static int MAX_LIMIT = 50;
    public static void main(String[] args) {
        new Thread(() -> {
            while (INIT_VALUE < MAX_LIMIT) {
                System.out.println("T1---" + (++INIT_VALUE));
                try {
                    Thread.sleep(1_00);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "ADDER-1").start();

        new Thread(() -> {
            while (INIT_VALUE < MAX_LIMIT) {
                System.out.println("T2---" + (++INIT_VALUE));
                try {
                    Thread.sleep(1_00);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "ADDER-2").start();
    }
}

打印：

注意和第一个的区别。

++会触发去主内存拿去刷新，但是刷新到主存可能是不及时的。

 new Thread(() -> {
            int localValue = INIT_VALUE;
            while (localValue < MAX_LIMIT) {
                //System.out.println(INIT_VALUE+" "+localValue);
                if (localValue != INIT_VALUE) {
                    System.out.println(INIT_VALUE+" "+localValue);
                    System.out.println("The value1 READER to" + INIT_VALUE);
                    localValue = INIT_VALUE;
                }
            }
        }, "READER").start();

因为在这个线程里每次都是读，没有感知到写就不去主内存拿值。

当前线程有写才会感知。在线程没有写的操作。不需要再主内存去拿。

----------------------------------------------06---------------------------------------------------