首页 / JAVA / 【Java并发编程实战-阅读笔记】02-对象的共享

【Java并发编程实战-阅读笔记】02-对象的共享

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【Java并发编程实战-阅读笔记】02-对象的共享，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6769字，纯文字阅读大概需要10分钟。

内容图文

        编写正确的并发程序需要在访问可变状态的时候进行正确的管理。前面说了如何通过同步避免多个线程在同一个时刻访问相同的数据，本章介绍如何共享和发布对象，才能让对象安全地被多个线程同时访问。
        synchronized只是实现了原子性和临界区。我们还希望某个线程修改对象状态后，其他线程能够立刻看到状态的变化。

3.1 可见性

        一般情况下，我们无法保证执行读操作的线程能够立刻看到其他线程写入的值，比如下面的例子：
                    public
                    class
                     NoVisibility {
    
                    private
                    static
                    boolean
                     ready;
    
                    private
                    static
                    int
                     number;

    
                    public
                    static
                    class ReaderThread extends Thread {
        publicvoid run() {
            while (!ready) {
                Thread.yield();
            }
            System.out.println(number);
        }
    }

    publicstaticvoid main(String[] args) throws Exception {
        new ReaderThread().start();
        number = 42;
        ready = true;
        System.out.println("赋值结束");
    }
}
上面的代码虽然看起来没有问题，运行起来似乎也正确。但是，会存在如下可能性：
1、线程输出了0。（未测试出来）因为CPU会对指令编码进行重排序，导致“ready=true”先执行，“member=42”后执行。
2、死循环。虽然静态变量是公共的，子线程可能永远看不到主线程修改后的值。（因为子线程看到的是线程自身缓存的值，如果没有一个适当的触发机制让线程内的缓存重新触发更新，那么尽管主线程修改了静态变量，子线程仍然看不到修改后的值）
经过修改后的代码，就能出现死循环的情况：
                        public
                        class
                         NoVisibility {
    
                        private
                        static
                        boolean
                         ready;
    
                        private
                        static
                        int
                         number;

    
                        public
                        static
                        class ReaderThread extends Thread {
        publicvoid run() {
            int i = 0;
            while (!ready) {
                i++;
                /* 把下面这句print代码放开，就能触发内存更新，线程才能读取新的ready的值。 *///                System.out.println("--进入循环体-");/*通知系统放弃执行该线程，转交其他线程,自己可能会由运行态-->可运行态 *///                Thread.yield();            }
            System.out.println(number + "," + i);
        }
    }

    publicstaticvoid main(String[] args) throws Exception {
        new ReaderThread().start();
        Thread.sleep(5);
//        TimeUnit.MILLISECONDS.sleep(10);
        number = 42;
        ready = true;
        System.out.println("赋值结束");
    }
}

一、失效数据

        上面由于ready没有及时获取主线程更新到静态变量的值，还是用了之前的值做判断，称之为失效数据，这也是缺乏同步的表现。
        这种失效数据可能会导致意料之外的异常、被破坏的数据结构、不精确的计算以及无限循环等。
                        @NotThreadSafe

                        public
                        class
                         MutableInteger(){
    
                        private
                        int
                         value;
    
                        public
                        int get(){return value;}
    publicvoid set(int value){this.value = value;}
}
        上面这个代码，看起来没问题，但是不是线程安全的。如果某个线程调用了set，另一个线程正好在调用get，虽然set要比get早一点点（甚至1纳秒），但是却不能保证get的值是新值还是旧值。
        这里如果只对set同步是不行的，还要对get进行同步。
                        @ThreadSafe

                        public
                        class
                         MutableInteger(){
    
                        private
                        int
                         value;
    
                        public
                        synchronized
                        int get(){return value;}
    publicsynchronizedvoid set(int value){this.value = value;}
}

二、非原子的64位操作

        一般情况下，就算是失效数据，至少也是曾经有效的，并不是一个随机的值。这个安全性保证称之为最低安全性。
        有一种特殊的情况不是最低安全性。普通的64位数值变量，比如double或者long，在Java内存模型里面，读和写都是非原子操作。因为JVM会将64位读写操作拆分为两个32位的操作。因此，在并发读写的时候，可能会读的到某个高32位的值和另一个低32位的值。这个就是一个奇怪的值。

三、加锁与可见性

        内置锁能够保证一个线程可以正确查看到另一个线程的执行结果。也就是说，对于某个锁M。线程A在unlock M之前的所有操作，在B线程 lock M的时候，都能够看到前一个同步代码块的操作的结果。
        加锁不仅仅在于互斥，而且还包括内存可见性。因此，为了确保所有的线程都能看到共享变量的最新纸，所有执行读操作和写操作的线程都必须在同一个锁上同步。

四、Volatile变量

        Volatile是一种稍微弱的同步机制，就是解决内存可见性的。通过这个volatile，可以确保将变量的更新操作通知到其他线程。把变量声明为volatile类型之后，编译器和运行时都会注意到这个变量是共享的：
（1）就不会把该变量上的操作和其他内存操作一起进行重排序；
（2）volatile变量不会被缓存再寄存器或者其他处理器不可见的地方。
        因此，读取volatile变量的时候，永远都会返回最新的值。上面的对象定义中，可以改成“private volatile int value;”这样，既不会使线程阻塞，也能够保证内存可见性。所以，volatile是轻量级的同步机制。（目前大多数处理器架构，读取volatile变量的开销，比读取非volatile变量的开销稍微高一点）
        从内存可见性来看，写入volatile变量，相当于unlock M，读取volatile相当于lock M。但是不建议过度依赖volatile。
        volatile一般推荐用于状态位标志，对于复合操作，volatile满足不了原子性。
        加锁机制既能保证原子性，又能保证可见性。volatile只能保存可见性。

3.2 发布与溢出

        发布就是指，对象能够在当前作用域之外的代码中使用。如果不该发布的对象发布出去，就会出现溢出。
（1）我们往往需要需要确保对象以及对象内部的状态不能被发布出去。
（2）如果需要发布对象，我们要保证发布时的线程安全，不能破坏线程安全性。
例1：公共静态变量的对象发布。看下面的例子：
                        public
                        static Set<Secret> knownSecrets;
publicvoid initialize(){
    knownSecrets = new HashSet<Secret>();
}
   这里，如果knownSecrets的Set发布的话，其内部的Secret对象就会被间接的发布出去。
例2：私有变量被发布，逃出了其本来的作用域。 看下面的例子：
                        class
                         UnsafeStates {
    
                        private String[] states = new String[]{"AK","AL"}
    public String[] getStates(){return states;}
}
如果按照这种方式发布states，就会出现问题，因为任何调用者都能修改这个数组内容，本来私有的变量，结果却被发布了。
        当发布一个对象的时候，该对象的非私有域中引用的所有对象都会被发布，包括通过非私有的变量或者方法到达的其他对象。
例3：发不了一个内部的类实例。再看下面的例子，问题更大。
                        public
                        class
                         ThisEscape {
    
                        public
                         ThisEscape(EventSource source){
        source.registerListener{
            
                        new
                         EventListener(){
                
                        public
                        void
                         onEvent(Event e){
                    doSomething();
                }
            }
        }
    }
    
                        public
                        void
                         doSomething(){
     
                        //
                        ……
                            }
}
上面的代码解释如下：在ThisEscape的构造函数中，通过EventSource注册了一个事件监听器。当执行“source.registerListener”的时候，等于开启了一个线程，当事件发生的时候，会执行ThisEscape对象的doSomething()方法。也就是“this.doSomething()”。主线程和线程B对“this”都是可见的。线程B本质上是拿到了ThisEscape对象的“this”，然后执行的doSomething()方法。
        如果在ThisEscape构造函数还没有初始化完成的时候，就发生了event事件，那么就会调用“this.doSomething”方法，但是，这个时候，ThisEscape还没有初始化完成，其他线程就已经使用了“this”，这里，就是this逸出。这会导致一些不可预料的现象发生。当且仅当对象的构造函数返回时，对象才会处于和预测的一致的状态。
        不要在构造函数中让this引用逸出。
        当构造函数启动一个新线程的时候，无论是new Thread()，还是通过Runnable接口，this都会被新创建的线程共享。
例4：上面的例子的加强版。只要线程被启动，该线程都能获取到“this”，然后使用this的时候，就会出问题。 
                        public
                        class
                         ThisEscape {
    
                        private
                         String name;

    
                        public
                         ThisEscape(String name) {

        
                        new Thread(new Runnable() {
            @Override
            publicvoid run() {
                System.out.println(ThisEscape.this.name);
            }
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.name = name;
    }

    publicstaticvoid main(String[] args) {
        new ThisEscape("shenggang");
    }
}
打印“ThisEscape.this.name”会出现null。
例5：使用工厂方法，私有化构造函数，避免this逸出。
                        public
                        class
                         SafeListener {
    
                        private
                        final
                         EventListener listener;
    
                        private
                         SafeListener(){
        listener = new EventListener() {
            publicvoid onEvent(Event e){
                doSomething(e);
            }
        };
    }
    
    publicstatic SafeListener newInstance(EventSource source){
        SafeListener safe = new SafeListener();
        source.registerListener(safe.listener);
        return safe;
    }
}
上面的代码，通过工厂方法，newInstance的时候，只是创建了一个safe对象。这个时候，并没有线程在用。等safe创建完成之后，其他线程可以随意的使用了也不会有影响。

3.3 线程封闭

        线程封闭（Thread Confinement），就是指不共享数据，数据仅仅在单线程里面访问。这是最简单的线程安全性的实现方式。
        典型使用：Swing（封闭到事件的分发线程）。JDBC的Connection对象（从连接池获取的connection对象，都是由单线程采用同步的方式处理）。

（1）Ad-hoc线程封闭

        完成通过程序去控制数据只能在某个线程中访问。很脆弱，不建议使用。

（2）栈封闭

        线程封闭的特例。只能通过局部变量才能访问对象。因为局部变量的特点是，如果它们位于执行线程的栈中，那么其他线程是无法访问到这个栈的。也就是说，方法内的变量，其他线程是看不到的。
  
privateint loadTheArk(Collection<Animal> candidates) {
        SortedSet<Animal> animals;
        int numPairs = 0;
        Animal candidate = null;

        /* animals被封闭在方法中 */
        animals = new TreeSet<Animal>();
        animals.addAll(candidates);
        for(Animal a : animals){
            if(candidate == null || !candidate.isGood()){
                candidate = a;
            } else {
                ++numPairs;
            }
        }

        return numPairs;
    }
上面的代码，“animals”被封闭在了方法中，也就是局部变量，那么其他线程是看不到的。

（3）ThreadLocal类

        维持线程封闭性，更好的规范方法是使用ThreadLocal。这个类可以试线程中的某个值和保存值的对象关联起来。ThreadLocal提供了get和set等方法接口
        场景1：
        ThreadLocal最典型的应用场景：connection数据库连接。一般情况下，为了避免每次调用方法都要传递一个Connection变量，因此一般Connection会创建为一个全局的数据库连接变量。如果多线程的情况下，大家都会取使用，而Connection本身不是线程安全的。那么，就可以将JDBC的连接保存到ThreadLocal对象中，每个线程都会有一个属于自己的连接。
        本质上，ThreadLocal对象用于放置可变的单例变量或者全局变量进行共享。
        场景2：
        某个频繁的操作需要一个临时对象，由不希望每次执行的时候，都去重新分配该临时对象，可以使用ThreadLocal。
        场景3：
        单线程的程序移植到多线程里，可以将共享的全局变量移动到ThreadLocal中，可以保持线程的安全性。
 
        关于ThreadLocal的理解
1、ThreadLocal不是控制并发访问同一个对象，而是给每个线程分配一个只属于该线程的“线程级别的局部变量”。
2、ThreadLocal本质上是ThreadLocalMap，在connection中，每次创建新线程，就会从连接池中取出一个conn连接，放到该线程的ThreadLocal中，这样可以保证线程内事务的统一。
3、ThreadLocal中的ThreadLocalMap，使用了弱引用（当没有外部强引用的时候，就会被GC掉）。在用完某个ThreadLocal之后，如果没有及时remove，会导致map中key为null的entry，这些对应的value永远无法被回收，造成内存泄漏。
4、ThreadLocal使用场景：ThreadLocal不是解决对象共享访问的问题的，而是一种避免频繁复杂的参数传递，而采用的一种方便的对象访问方式。最适合在多线程中，每个线程都需要一个实例的对象访问，而且这个对象会在该线程中频繁使用。

（4）不变性

        不变对象可以满足同步需求。不可变的对象一定是线程安全的。该对象只能通过构造函数创建。
        注意，虽然不变对象可以用final类型声明，但是，final类型的数据的域中，还是可以保存可变对象的引用的。
 
 
 
 
 
 
 
 
 
 
 
 
 
 

原文：https://www.cnblogs.com/shenggang/p/8521911.html

内容总结

以上是互联网集市为您收集整理的【Java并发编程实战-阅读笔记】02-对象的共享全部内容，希望文章能够帮你解决【Java并发编程实战-阅读笔记】02-对象的共享所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1239918.html

来源：【匿名】